TzKT API

v1.13.3

Base URL

https://xtz-index.nownodes.io

Authentication

api-keyAuthapiKey

API Key: api-key in header

Indexer

Accounts

Get accounts

GET

https://xtz-index.nownodes.io/v1/accounts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of accounts.

Parameters

idInt32Parameter | nullquery

Filters by internal id.

addressAddressParameter | nullquery

Filters by address.

typeAccountTypeParameter | nullquery

Filters accounts by type (user, delegate, contract, rollup, smart_rollup, ghost).

kindContractKindParameter | nullquery

Filters accounts by contract kind (delegator_contract or smart_contract)

delegateAccountParameter | nullquery

Filters accounts by delegate. Allowed fields for .eqx mode: none.

balanceInt64Parameter | nullquery

Filters accounts by balance

stakedBoolParameter | nullquery

Filters accounts by participation in staking

lastActivityInt32Parameter | nullquery

Filters accounts by last activity level (where the account was updated)

selectSelectParameter | nullquery

Specify comma-separated list of fields to include into response or leave it undefined to return full object. If you select single field, response will be an array of values in both .fields and .values modes.

sortSortParameter | nullquery

Sorts delegators by specified field. Supported fields: id (default), balance, rollupBonds, firstActivity, lastActivity, numTransactions, numContracts.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get accounts

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/accounts";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "type": "string"
  }
]

Get accounts count

GET

https://xtz-index.nownodes.io/v1/accounts/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a number of accounts.

Parameters

typeAccountTypeParameter | nullquery

Filters accounts by type (user, delegate, contract, rollup, smart_rollup, ghost).

kindContractKindParameter | nullquery

Filters accounts by contract kind (delegator_contract or smart_contract)

balanceInt64Parameter | nullquery

Filters accounts by balance

stakedBoolParameter | nullquery

Filters accounts by participation in staking

firstActivityInt32Parameter | nullquery

Filters accounts by first activity level (where the account was created)

Response

200OK

Get accounts count

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/count')
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://xtz-index.nownodes.io/v1/accounts/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/count')
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

Get account by address

GET

https://xtz-index.nownodes.io/v1/accounts/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an account with the specified address.

Parameters

addressstringrequiredpath

Account address

legacybooleantruequery

If true (by default), the metadata field will contain tzkt profile info, or TZIP-16 metadata otherwise. This is a part of a deprecation mechanism, allowing smooth migration.

Response

200OK

Get account by address

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts/{address}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/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://xtz-index.nownodes.io/v1/accounts/{address}')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/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

{
  "type": "string"
}

Get account contracts

GET

https://xtz-index.nownodes.io/v1/accounts/{address}/contracts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of contracts created by (or related to) the specified account.

Parameters

addressstringrequiredpath

Account address (starting with tz or KT)

sortSortParameter | nullquery

Sorts contracts by specified field. Supported fields: id (default, desc), balance, creationLevel.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get account contracts

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts/{address}/contracts'

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/contracts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/contracts')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/{address}/contracts')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/contracts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/accounts/{address}/contracts";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/contracts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/{address}/contracts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/contracts')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "kind": "string",
    "alias": "string",
    "address": "string",
    "balance": 0,
    "delegate": {
      "alias": "string",
      "address": "string",
      "active": true
    },
    "creationLevel": 0,
    "creationTime": "2024-01-15T09:30:00Z"
  }
]

Get account delegators

GET

https://xtz-index.nownodes.io/v1/accounts/{address}/delegators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of accounts delegated to the specified account.

Parameters

addressstringrequiredpath

Account address (starting with tz)

typeAccountTypeParameter | nullquery

Filters delegators by type (user, delegate, contract, rollup, smart_rollup, ghost).

balanceInt64Parameter | nullquery

Filters delegators by balance.

delegationLevelInt32Parameter | nullquery

Number of items to skip

sortSortParameter | nullquery

Sorts delegators by specified field. Supported fields: delegationLevel (default, desc), balance.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get account delegators

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts/{address}/delegators'

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/delegators', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/delegators')
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://xtz-index.nownodes.io/v1/accounts/{address}/delegators')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/delegators', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/{address}/delegators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/delegators')
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

[
  {
    "type": "string",
    "alias": "string",
    "address": "string",
    "balance": 0,
    "delegationLevel": 0,
    "delegationTime": "2024-01-15T09:30:00Z"
  }
]

Get account operations

GET

https://xtz-index.nownodes.io/v1/accounts/{address}/operations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of operations related to the specified account. Note: for better flexibility this endpoint accumulates query parameters (filters) of each /operations/{type} endpoint, so a particular filter may affect several operation types containing this filter. For example, if you specify an initiator it will affect all transactions, delegations and originations, because all these types have an initiator field.
NOTE: if you know in advance what operation type you want to get (e.g. transactions), prefer using /v1/operations/{type} (e.g. /v1/operations/transactions) instead, because it's much more efficient and way more flexible.

Parameters

addressstringrequiredpath

Account address

typestring | nullquery

Comma separated list of operation types to return (endorsement, preendorsement, ballot, proposal, activation, double_baking, double_endorsing, double_preendorsing, nonce_revelation, vdf_revelation, delegation, origination, transaction, reveal, register_constant, set_deposits_limit, increase_paid_storage, tx_rollup_origination, tx_rollup_submit_batch, tx_rollup_commit, tx_rollup_return_bond, tx_rollup_finalize_commitment, tx_rollup_remove_commitment, tx_rollup_rejection, tx_rollup_dispatch_tickets, transfer_ticket, migration, update_consensus_key, drain_delegate, sr_add_messages, sr_cement, sr_execute, sr_originate, sr_publish, sr_recover_bond, sr_refute, revelation_penalty, baking, endorsing_reward). If not specified then the default set will be returned.

initiatorAccountParameter | nullquery

Filters transactions, delegations and originations by initiator. Allowed fields for .eqx mode: none.

senderAccountParameter | nullquery

Filters transactions, delegations, originations, reveals and seed nonce revelations by sender. Allowed fields for .eqx mode: none.

targetAccountParameter | nullquery

Filters transactions by target. Allowed fields for .eqx mode: none.

prevDelegateAccountParameter | nullquery

Filters delegations by prev delegate. Allowed fields for .eqx mode: none.

newDelegateAccountParameter | nullquery

Filters delegations by new delegate. Allowed fields for .eqx mode: none.

contractManagerAccountParameter | nullquery

Filters origination operations by manager. Allowed fields for .eqx mode: none.

contractDelegateAccountParameter | nullquery

Filters origination operations by delegate. Allowed fields for .eqx mode: none.

originatedContractAccountParameter | nullquery

Filters origination operations by originated contract. Allowed fields for .eqx mode: none.

accuserAccountParameter | nullquery

Filters double baking and double endorsing by accuser. Allowed fields for .eqx mode: none.

offenderAccountParameter | nullquery

Filters double baking and double endorsing by offender. Allowed fields for .eqx mode: none.

bakerAccountParameter | nullquery

Filters seed nonce revelation operations by baker. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters operations by level.

timestampDateTimeParameter | nullquery

Filters operations by timestamp.

entrypointStringParameter | nullquery

Filters transactions by entrypoint called on the target contract.

parameterJsonParameter | nullquery

hasInternalsBoolParameter | nullquery

Filters transactions by presence of internal operations.

statusOperationStatusParameter | nullquery

Filters transactions, delegations, originations and reveals by operation status (applied, failed, backtracked, skipped).

sortSortModeDescendingquery

Sort mode (0 - ascending, 1 - descending), operations of different types can only be sorted by ID.

lastIdinteger<int64> | nullquery

Id of the last operation received, which is used as an offset for pagination

limitinteger<int32>[0, 1000]100query

Number of items to return

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get account operations

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts/{address}/operations'

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/operations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/operations')
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://xtz-index.nownodes.io/v1/accounts/{address}/operations')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/operations', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/{address}/operations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/operations')
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

[
  {
    "type": "string"
  }
]

Get counter

GET

https://xtz-index.nownodes.io/v1/accounts/{address}/counter

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns account counter

Parameters

addressstringrequiredpath

Account address (starting with tz or KT)

Response

200OK

Get counter

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts/{address}/counter'

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/counter', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/counter')
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://xtz-index.nownodes.io/v1/accounts/{address}/counter')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/counter', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/{address}/counter')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/counter')
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

Get balance

GET

https://xtz-index.nownodes.io/v1/accounts/{address}/balance

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns account balance

Parameters

addressstringrequiredpath

Account address (starting with tz or KT)

Response

200OK

Get balance

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts/{address}/balance'

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/balance', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/balance')
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://xtz-index.nownodes.io/v1/accounts/{address}/balance')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/balance', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/{address}/balance')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/balance')
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

Get balance at level

GET

https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{level}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns account balance at the specified block

Parameters

addressstringrequiredpath

Account address (starting with tz or KT)

levelinteger<int32>requiredpath

Block height at which you want to know account balance

Response

200OK

Get balance at level

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{level}'

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{level}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{level}')
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://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{level}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{level}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{level}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{level}')
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

Get balance at date

GET

https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{datetime}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns account balance at the specified datetime

Parameters

addressstringrequiredpath

Account address (starting with tz or KT)

datetimestring<date-time>requiredpath

Datetime at which you want to know account balance (e.g. 2020-01-01, or 2019-12-30T23:42:59Z)

Response

200OK

Get balance at date

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{datetime}'

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{datetime}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{datetime}')
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://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{datetime}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{datetime}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{datetime}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history/{datetime}')
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

Get balance history

GET

https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns time series with historical balances (only changes, without duplicates).

Parameters

addressstringrequiredpath

Account address (starting with tz or KT)

stepinteger<int32> | nullquery

Step of the time series, for example if step = 1000 you will get balances at blocks 1000, 2000, 3000, ....

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts historical balances by specified field. Supported fields: level.

offsetinteger<int32>0query

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get balance history

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history'

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history')
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://xtz-index.nownodes.io/v1/accounts/{address}/balance_history')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/balance_history')
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

[
  {
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "balance": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get account report

GET

https://xtz-index.nownodes.io/v1/accounts/{address}/report

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Exports account balance report in .csv format

Parameters

addressstringrequiredpath

Account address (starting with tz or KT)

fromstring<date-time> | nullquery

Start of the datetime range to filter by (ISO 8601, e.g. 2019-11-31)

tostring<date-time> | nullquery

End of the datetime range to filter by (ISO 8601, e.g. 2019-12-31)

currencystring | nullquery

Currency to convert amounts to (btc, eur, usd, cny, jpy, krw, eth, gbp)

historicalbooleanfalsequery

true if you want to use historical prices, false to use current price

delimiterstring | nullcommaquery

Column delimiter (comma, semicolon)

separatorstring | nullpointquery

Decimal separator (comma, point)

Response

200OK

Get account report

curl -X GET 'https://xtz-index.nownodes.io/v1/accounts/{address}/report'

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/report', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/report')
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://xtz-index.nownodes.io/v1/accounts/{address}/report')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/accounts/{address}/report', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/accounts/{address}/report')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/accounts/{address}/report')
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

"<binary>"

BigMaps

Get bigmaps count

GET

https://xtz-index.nownodes.io/v1/bigmaps/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of bigmaps.

Response

200OK

Get bigmaps count

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/count')
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://xtz-index.nownodes.io/v1/bigmaps/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/count')
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

Get bigmaps

GET

https://xtz-index.nownodes.io/v1/bigmaps

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of bigmaps.

Parameters

contractAccountParameter | nullquery

Filters bigmaps by smart contract address.

pathStringParameter | nullquery

Filters bigmaps by path in the contract storage.

tagsBigMapTagsParameter | nullquery

Filters bigmaps by tags: metadata, token_metadata, ledger.

activeboolean | nullquery

Filters bigmaps by status: true - active, false - removed.

lastLevelInt32Parameter | nullquery

Filters bigmaps by the last update level.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts bigmaps by specified field. Supported fields: id (default), ptr, firstLevel, lastLevel, totalKeys, activeKeys, updates.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the bigmap key and value type: 0 - JSON, 2 - Micheline

Response

200OK

Get bigmaps

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps')
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

[
  {
    "ptr": 0,
    "contract": {
      "alias": "string",
      "address": "string"
    },
    "path": "string",
    "tags": [
      "string"
    ],
    "active": true,
    "firstLevel": 0,
    "lastLevel": 0,
    "totalKeys": 0,
    "activeKeys": 0,
    "updates": 0
  }
]

Get bigmap keys

GET

https://xtz-index.nownodes.io/v1/bigmaps/keys

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of all bigmap keys.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

bigmapInt32Parameter | nullquery

Filter by bigmap ptr.
Click on the parameter to expand more details.

activeboolean | nullquery

Filters by status: true - active, false - removed.

hashExpressionParameter | nullquery

Filter by key hash.
Click on the parameter to expand more details.

keyJsonParameter | nullquery

Filter by key.
Note, this parameter supports the following format: key{.path?}{.mode?}=..., so you can specify a path to a particular field to filter by (for example, ?key.foo.in=bar,baz).
Click on the parameter to expand more details.

valueJsonParameter | nullquery

Filter by value.
Note, this parameter supports the following format: value{.path?}{.mode?}=..., so you can specify a path to a particular field to filter by (for example, ?value.foo.in=bar,baz).
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block where the key was first seen.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the key was first seen.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block where the key was last seen.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the key was last seen.
Click on the parameter to expand more details.

updatesInt32Parameter | nullquery

Filter by number of actions with the bigmap key.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Specify a comma-separated list of fields to include into response or leave it undefined to get default set of fields. This parameter accepts values of the following format: {field}{path?}{as alias?}, so you can do deep selection (for example, ?select=balance,token.metadata.symbol as token,...).
Note, if you select just one field, the response will be flatten into a simple array of values.
Click on the parameter to expand the details.

michelineMichelineFormatJsonquery

Format of the key and value fields: 0 - JSON, 2 - Micheline

Response

200OK

Get bigmap keys

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps/keys'

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/keys', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/keys')
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://xtz-index.nownodes.io/v1/bigmaps/keys')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/keys', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps/keys')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/keys')
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": 0,
    "bigmap": 0,
    "active": true,
    "hash": "string",
    "firstLevel": 0,
    "firstTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "lastTime": "2024-01-15T09:30:00Z",
    "updates": 0
  }
]

Get bigmap updates count

GET

https://xtz-index.nownodes.io/v1/bigmaps/updates/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of bigmap updates.

Parameters

bigmapInt32Parameter | nullquery

Filters by bigmap ptr

pathStringParameter | nullquery

Filters by bigmap path

contractAccountParameter | nullquery

Filters by bigmap contract

tagsBigMapTagsParameter | nullquery

Filters by bigmap tags: metadata, token_metadata, ledger

actionBigMapActionParameter | nullquery

Filters by action

valueJsonParameter | nullquery

Filters by JSON value. Note, this query parameter supports the following format: ?value{.path?}{.mode?}=..., so you can specify a path to a particular field to filter by, for example: ?value.balance.gt=....

levelInt32Parameter | nullquery

Filters by level

timestampTimestampParameter | nullquery

Filters by timestamp

Response

200OK

Get bigmap updates count

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps/updates/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/updates/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/updates/count')
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://xtz-index.nownodes.io/v1/bigmaps/updates/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/updates/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/bigmaps/updates/count";
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://xtz-index.nownodes.io/v1/bigmaps/updates/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps/updates/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/updates/count')
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": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "bigmap": 0,
    "contract": {
      "alias": "string",
      "address": "string"
    },
    "path": "string",
    "action": "string",
    "content": {
      "hash": "string"
    }
  }
]

Get bigmap updates

GET

https://xtz-index.nownodes.io/v1/bigmaps/updates

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of all bigmap updates.

Parameters

bigmapInt32Parameter | nullquery

Filters by bigmap ptr

pathStringParameter | nullquery

Filters by bigmap path

contractAccountParameter | nullquery

Filters by bigmap contract

tagsBigMapTagsParameter | nullquery

Filters by bigmap tags: metadata, token_metadata, ledger

actionBigMapActionParameter | nullquery

Filters by action

valueJsonParameter | nullquery

levelInt32Parameter | nullquery

Filters by level

timestampTimestampParameter | nullquery

Filters by timestamp

sortSortParameter | nullquery

Sorts bigmaps by specified field. Supported fields: id (default), ptr, firstLevel, lastLevel, totalKeys, activeKeys, updates.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the bigmap key and value type: 0 - JSON, 2 - Micheline

Response

200OK

Get bigmap updates

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps/updates'

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/updates', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/updates')
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://xtz-index.nownodes.io/v1/bigmaps/updates')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/updates', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps/updates')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/updates')
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": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "bigmap": 0,
    "contract": {
      "alias": "string",
      "address": "string"
    },
    "path": "string",
    "action": "string",
    "content": {
      "hash": "string"
    }
  }
]

Get bigmap by Id

GET

https://xtz-index.nownodes.io/v1/bigmaps/{id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a bigmap with the specified Id.

Parameters

idinteger<int32>requiredpath

Bigmap Id

michelineMichelineFormatJsonquery

Format of the bigmap key and value type: 0 - JSON, 2 - Micheline

Response

200OK

Get bigmap by Id

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps/{id}'

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{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://xtz-index.nownodes.io/v1/bigmaps/{id}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps/{id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{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

{
  "ptr": 0,
  "contract": {
    "alias": "string",
    "address": "string"
  },
  "path": "string",
  "tags": [
    "string"
  ],
  "active": true,
  "firstLevel": 0,
  "lastLevel": 0,
  "totalKeys": 0,
  "activeKeys": 0,
  "updates": 0
}

Get bigmap type

GET

https://xtz-index.nownodes.io/v1/bigmaps/{id}/type

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a type of the bigmap with the specified Id in Micheline format (with annotations).

Parameters

idinteger<int32>requiredpath

Bigmap Id

Response

200OK

Get bigmap type

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps/{id}/type'

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/type', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/type')
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://xtz-index.nownodes.io/v1/bigmaps/{id}/type')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/type', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/bigmaps/{id}/type";
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://xtz-index.nownodes.io/v1/bigmaps/{id}/type', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps/{id}/type')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/type')
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

{
  "prim": 0,
  "args": [
    {
      "type": 0
    }
  ],
  "annots": [
    {
      "type": 0,
      "value": "string"
    }
  ]
}

Get bigmap keys

GET

https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of bigmap keys.

Parameters

idinteger<int32>requiredpath

Bigmap Id

activeboolean | nullquery

Filters keys by status: true - active, false - removed.

keyJsonParameter | nullquery

Filters keys by JSON key. Note, this query parameter supports the following format: ?key{.path?}{.mode?}=..., so you can specify a path to a particular field to filter by, for example: ?key.token_id=....

valueJsonParameter | nullquery

Filters keys by JSON value. Note, this query parameter supports the following format: ?value{.path?}{.mode?}=..., so you can specify a path to a particular field to filter by, for example: ?value.balance.gt=....

lastLevelInt32Parameter | nullquery

Filters bigmap keys by the last update level.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts bigmap keys by specified field. Supported fields: id (default), firstLevel, lastLevel, updates.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the bigmap key and value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get bigmap keys

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys'

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys')
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://xtz-index.nownodes.io/v1/bigmaps/{id}/keys')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys";
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://xtz-index.nownodes.io/v1/bigmaps/{id}/keys', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys')
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": 0,
    "active": true,
    "hash": "string",
    "firstLevel": 0,
    "lastLevel": 0,
    "updates": 0
  }
]

Get bigmap key

GET

https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the specified bigmap key.

Parameters

idinteger<int32>requiredpath

Bigmap Id

keystringrequiredpath

Either a key hash (expr123...) or a plain value (foo...). Even if the key is complex (an object or an array), you can specify it as is, for example, /keys/{"address":"tz123","nat":"123"}.

michelineMichelineFormatJsonquery

Format of the bigmap key and value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get bigmap key

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}'

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{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://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{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://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{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

{
  "id": 0,
  "active": true,
  "hash": "string",
  "firstLevel": 0,
  "lastLevel": 0,
  "updates": 0
}

Get bigmap key updates

GET

https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}/updates

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns updates history for the specified bigmap key.

Parameters

idinteger<int32>requiredpath

Bigmap Id

keystringrequiredpath

Either a key hash (expr123...) or a plain value (foo...). Even if the key is complex (an object or an array), you can specify it as is, for example, /keys/{"address":"tz123","nat":"123"}.

sortSortParameter | nullquery

Sorts bigmap updates by specified field. Supported fields: id (default).

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the key value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get bigmap key updates

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}/updates'

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}/updates', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}/updates')
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://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}/updates')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}/updates', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}/updates";
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://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}/updates', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}/updates')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/keys/{key}/updates')
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": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "action": "string"
  }
]

Get historical keys

GET

https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of bigmap keys at the specific block.

Parameters

idinteger<int32>requiredpath

Bigmap Id

levelinteger<int32>requiredpath

Level of the block at which you want to get bigmap keys

activeboolean | nullquery

Filters keys by status: true - active, false - removed.

keyJsonParameter | nullquery

valueJsonParameter | nullquery

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts bigmap keys by specified field. Supported fields: id (default).

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the bigmap key and value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get historical keys

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}'

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}')
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://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}";
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://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}')
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": 0,
    "active": true,
    "hash": "string"
  }
]

Get historical key

GET

https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}/{key}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the specified bigmap key at the specific block.

Parameters

idinteger<int32>requiredpath

Bigmap Id

levelinteger<int32>requiredpath

Level of the block at which you want to get bigmap key

keystringrequiredpath

Either a key hash (expr123...) or a plain value (foo...). Even if the key is complex (an object or an array), you can specify it as is, for example, /keys/{"address":"tz123","nat":"123"}.

michelineMichelineFormatJsonquery

Format of the bigmap key and value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get historical key

curl -X GET 'https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}/{key}'

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}/{key}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}/{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://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}/{key}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}/{key}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}/{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://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}/{key}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}/{key}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/bigmaps/{id}/historical_keys/{level}/{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

{
  "id": 0,
  "active": true,
  "hash": "string"
}

Blocks

Get blocks count

GET

https://xtz-index.nownodes.io/v1/blocks/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of blocks.

Response

200OK

Get blocks count

curl -X GET 'https://xtz-index.nownodes.io/v1/blocks/count'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/blocks/count')
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

Get blocks

GET

https://xtz-index.nownodes.io/v1/blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of blocks.

Parameters

bakerAccountParameter | nullquery

[DEPRECATED]

anyofAnyOfParameter | nullquery

Filters by any of the specified fields. Example: anyof.proposer.producer=tz1....

proposerAccountParameter | nullquery

Filters blocks by block proposer. Allowed fields for .eqx mode: none.

producerAccountParameter | nullquery

Filters blocks by block producer. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters blocks by level.

timestampDateTimeParameter | nullquery

Filters blocks by timestamp.

priorityInt32Parameter | nullquery

[DEPRECATED]

blockRoundInt32Parameter | nullquery

Filters blocks by block round.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts blocks by specified field. Supported fields: id (default), level, payloadRound, blockRound, validations, reward, bonus, fees.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get blocks

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

200

[
  {
    "cycle": 0,
    "level": 0,
    "hash": "string",
    "timestamp": "2024-01-15T09:30:00Z",
    "proto": 0,
    "payloadRound": 0,
    "blockRound": 0,
    "validations": 0,
    "deposit": 0,
    "rewardLiquid": 0,
    "rewardStakedOwn": 0,
    "rewardStakedShared": 0,
    "bonusLiquid": 0,
    "bonusStakedOwn": 0,
    "bonusStakedShared": 0,
    "fees": 0,
    "nonceRevealed": true,
    "proposer": {
      "alias": "string",
      "address": "string"
    },
    "producer": {
      "alias": "string",
      "address": "string"
    },
    "software": {
      "version": "string",
      "date": "2024-01-15T09:30:00Z"
    },
    "lbToggle": true,
    "lbToggleEma": 0,
    "aiToggle": true,
    "aiToggleEma": 0,
    "endorsements": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "delegate": {
          "alias": "string",
          "address": "string"
        },
        "slots": 0,
        "deposit": 0,
        "rewards": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "preendorsements": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "delegate": {
          "alias": "string",
          "address": "string"
        },
        "slots": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "proposals": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "period": {
          "index": 0,
          "epoch": 0,
          "kind": "string",
          "firstLevel": 0,
          "lastLevel": 0
        },
        "proposal": {
          "alias": "string",
          "hash": "string"
        },
        "delegate": {
          "alias": "string",
          "address": "string"
        },
        "votingPower": 0,
        "duplicated": true,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        },
        "rolls": 0
      }
    ],
    "ballots": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "period": {
          "index": 0,
          "epoch": 0,
          "kind": "string",
          "firstLevel": 0,
          "lastLevel": 0
        },
        "proposal": {
          "alias": "string",
          "hash": "string"
        },
        "delegate": {
          "alias": "string",
          "address": "string"
        },
        "votingPower": 0,
        "vote": "string",
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        },
        "rolls": 0
      }
    ],
    "activations": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "account": {
          "alias": "string",
          "address": "string"
        },
        "balance": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "doubleBaking": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "accusedLevel": 0,
        "slashedLevel": 0,
        "accuser": {
          "alias": "string",
          "address": "string"
        },
        "reward": 0,
        "offender": {
          "alias": "string",
          "address": "string"
        },
        "lostStaked": 0,
        "lostUnstaked": 0,
        "lostExternalStaked": 0,
        "lostExternalUnstaked": 0,
        "roundingLoss": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        },
        "offenderLoss": 0,
        "accuserReward": 0,
        "accuserRewards": 0,
        "offenderLostDeposits": 0,
        "offenderLostRewards": 0,
        "offenderLostFees": 0
      }
    ],
    "doubleEndorsing": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "accusedLevel": 0,
        "slashedLevel": 0,
        "accuser": {
          "alias": "string",
          "address": "string"
        },
        "reward": 0,
        "offender": {
          "alias": "string",
          "address": "string"
        },
        "lostStaked": 0,
        "lostUnstaked": 0,
        "lostExternalStaked": 0,
        "lostExternalUnstaked": 0,
        "roundingLoss": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        },
        "offenderLoss": 0,
        "accuserReward": 0,
        "accuserRewards": 0,
        "offenderLostDeposits": 0,
        "offenderLostRewards": 0,
        "offenderLostFees": 0
      }
    ],
    "doublePreendorsing": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "accusedLevel": 0,
        "slashedLevel": 0,
        "accuser": {
          "alias": "string",
          "address": "string"
        },
        "reward": 0,
        "offender": {
          "alias": "string",
          "address": "string"
        },
        "lostStaked": 0,
        "lostUnstaked": 0,
        "lostExternalStaked": 0,
        "lostExternalUnstaked": 0,
        "roundingLoss": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        },
        "offenderLoss": 0,
        "accuserReward": 0
      }
    ],
    "nonceRevelations": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "baker": {
          "alias": "string",
          "address": "string"
        },
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "revealedLevel": 0,
        "revealedCycle": 0,
        "nonce": "string",
        "rewardLiquid": 0,
        "rewardStakedOwn": 0,
        "rewardStakedShared": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        },
        "reward": 0,
        "bakerRewards": 0
      }
    ],
    "vdfRevelations": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "baker": {
          "alias": "string",
          "address": "string"
        },
        "cycle": 0,
        "solution": "string",
        "proof": "string",
        "rewardLiquid": 0,
        "rewardStakedOwn": 0,
        "rewardStakedShared": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        },
        "reward": 0
      }
    ],
    "delegations": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "counter": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "senderCodeHash": 0,
        "nonce": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "amount": 0,
        "unstakedPseudotokens": 0,
        "unstakedBalance": 0,
        "unstakedRewards": 0,
        "prevDelegate": {
          "alias": "string",
          "address": "string"
        },
        "newDelegate": {
          "alias": "string",
          "address": "string"
        },
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "originations": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "counter": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "senderCodeHash": 0,
        "nonce": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "storageUsed": 0,
        "bakerFee": 0,
        "storageFee": 0,
        "allocationFee": 0,
        "contractBalance": 0,
        "contractManager": {
          "alias": "string",
          "address": "string"
        },
        "contractDelegate": {
          "alias": "string",
          "address": "string"
        },
        "diffs": [
          {
            "bigmap": 0,
            "path": "string",
            "action": "string",
            "content": {
              "hash": "string"
            }
          }
        ],
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "originatedContract": {
          "kind": "string",
          "alias": "string",
          "address": "string",
          "typeHash": 0,
          "codeHash": 0,
          "tzips": [
            "string"
          ]
        },
        "tokenTransfersCount": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "transactions": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "counter": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "senderCodeHash": 0,
        "nonce": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "storageUsed": 0,
        "bakerFee": 0,
        "storageFee": 0,
        "allocationFee": 0,
        "target": {
          "alias": "string",
          "address": "string"
        },
        "targetCodeHash": 0,
        "amount": 0,
        "parameter": {
          "entrypoint": "string"
        },
        "diffs": [
          {
            "bigmap": 0,
            "path": "string",
            "action": "string",
            "content": {
              "hash": "string"
            }
          }
        ],
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "hasInternals": true,
        "tokenTransfersCount": 0,
        "ticketTransfersCount": 0,
        "eventsCount": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "reveals": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "registerConstants": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "storageUsed": 0,
        "bakerFee": 0,
        "storageFee": 0,
        "status": "string",
        "address": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "setDepositsLimits": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "status": "string",
        "limit": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "transferTicketOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "storageUsed": 0,
        "bakerFee": 0,
        "storageFee": 0,
        "target": {
          "alias": "string",
          "address": "string"
        },
        "ticketer": {
          "alias": "string",
          "address": "string"
        },
        "amount": "string",
        "entrypoint": "string",
        "ticketTransfersCount": 0,
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "txRollupCommitOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "bond": 0,
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "txRollupDispatchTicketsOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "storageUsed": 0,
        "bakerFee": 0,
        "storageFee": 0,
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "txRollupFinalizeCommitmentOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "txRollupOriginationOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "allocationFee": 0,
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "txRollupRejectionOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "committer": {
          "alias": "string",
          "address": "string"
        },
        "reward": 0,
        "loss": 0,
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "txRollupRemoveCommitmentOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "txRollupReturnBondOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "bond": 0,
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "txRollupSubmitBatchOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "storageUsed": 0,
        "bakerFee": 0,
        "storageFee": 0,
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "increasePaidStorageOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "storageUsed": 0,
        "bakerFee": 0,
        "storageFee": 0,
        "status": "string",
        "contract": {
          "alias": "string",
          "address": "string"
        },
        "amount": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "updateConsensusKeyOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "status": "string",
        "activationCycle": 0,
        "publicKey": "string",
        "publicKeyHash": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "drainDelegateOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "hash": "string",
        "delegate": {
          "alias": "string",
          "address": "string"
        },
        "target": {
          "alias": "string",
          "address": "string"
        },
        "amount": 0,
        "fee": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "srAddMessagesOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "status": "string",
        "messagesCount": 0,
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "srCementOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "status": "string",
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "commitment": {
          "id": 0,
          "initiator": {
            "alias": "string",
            "address": "string"
          },
          "inboxLevel": 0,
          "state": "string",
          "hash": "string",
          "ticks": 0,
          "firstLevel": 0,
          "firstTime": "2024-01-15T09:30:00Z"
        },
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "srExecuteOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "storageUsed": 0,
        "bakerFee": 0,
        "storageFee": 0,
        "status": "string",
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "commitment": {
          "id": 0,
          "initiator": {
            "alias": "string",
            "address": "string"
          },
          "inboxLevel": 0,
          "state": "string",
          "hash": "string",
          "ticks": 0,
          "firstLevel": 0,
          "firstTime": "2024-01-15T09:30:00Z"
        },
        "errors": [
          {
            "type": "string"
          }
        ],
        "ticketTransfersCount": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "srOriginateOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "storageUsed": 0,
        "bakerFee": 0,
        "storageFee": 0,
        "status": "string",
        "pvmKind": "string",
        "kernel": "dGVzdA==",
        "genesisCommitment": "string",
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "srPublishOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "status": "string",
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "commitment": {
          "id": 0,
          "initiator": {
            "alias": "string",
            "address": "string"
          },
          "inboxLevel": 0,
          "state": "string",
          "hash": "string",
          "ticks": 0,
          "firstLevel": 0,
          "firstTime": "2024-01-15T09:30:00Z"
        },
        "bond": 0,
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "srRecoverBondOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "status": "string",
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "staker": {
          "alias": "string",
          "address": "string"
        },
        "bond": 0,
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "srRefuteOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "status": "string",
        "rollup": {
          "alias": "string",
          "address": "string"
        },
        "game": {
          "id": 0,
          "initiator": {
            "alias": "string",
            "address": "string"
          },
          "initiatorCommitment": {
            "id": 0,
            "initiator": {
              "alias": "string",
              "address": "string"
            },
            "inboxLevel": 0,
            "state": "string",
            "hash": "string",
            "ticks": 0,
            "firstLevel": 0,
            "firstTime": "2024-01-15T09:30:00Z"
          },
          "opponent": {
            "alias": "string",
            "address": "string"
          },
          "opponentCommitment": {
            "id": 0,
            "initiator": {
              "alias": "string",
              "address": "string"
            },
            "inboxLevel": 0,
            "state": "string",
            "hash": "string",
            "ticks": 0,
            "firstLevel": 0,
            "firstTime": "2024-01-15T09:30:00Z"
          },
          "initiatorReward": 0,
          "initiatorLoss": 0,
          "opponentReward": 0,
          "opponentLoss": 0
        },
        "move": "string",
        "gameStatus": "string",
        "dissectionStart": 0,
        "dissectionEnd": 0,
        "dissectionSteps": 0,
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "stakingOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "hash": "string",
        "sender": {
          "alias": "string",
          "address": "string"
        },
        "counter": 0,
        "gasLimit": 0,
        "gasUsed": 0,
        "storageLimit": 0,
        "bakerFee": 0,
        "kind": "string",
        "baker": {
          "alias": "string",
          "address": "string"
        },
        "amount": 0,
        "pseudotokens": 0,
        "limitOfStakingOverBaking": 0,
        "edgeOfBakingOverStaking": 0,
        "activationCycle": 0,
        "status": "string",
        "errors": [
          {
            "type": "string"
          }
        ],
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "migrations": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "kind": "string",
        "account": {
          "alias": "string",
          "address": "string"
        },
        "balanceChange": 0,
        "diffs": [
          {
            "bigmap": 0,
            "path": "string",
            "action": "string",
            "content": {
              "hash": "string"
            }
          }
        ],
        "tokenTransfersCount": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "revelationPenalties": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "baker": {
          "alias": "string",
          "address": "string"
        },
        "missedLevel": 0,
        "loss": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        },
        "lostReward": 0,
        "lostFees": 0
      }
    ],
    "endorsingRewards": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "block": "string",
        "baker": {
          "alias": "string",
          "address": "string"
        },
        "expected": 0,
        "rewardLiquid": 0,
        "rewardStakedOwn": 0,
        "rewardStakedShared": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        },
        "received": 0
      }
    ],
    "autostakingOps": [
      {
        "type": "string",
        "id": 0,
        "level": 0,
        "timestamp": "2024-01-15T09:30:00Z",
        "baker": {
          "alias": "string",
          "address": "string"
        },
        "action": "string",
        "cycle": 0,
        "amount": 0,
        "quote": {
          "btc": 0,
          "eur": 0,
          "usd": 0,
          "cny": 0,
          "jpy": 0,
          "krw": 0,
          "eth": 0,
          "gbp": 0
        }
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "reward": 0,
    "bonus": 0,
    "priority": 0,
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "lbEscapeVote": true,
    "lbEscapeEma": 0
  }
]

Get block by hash

GET

https://xtz-index.nownodes.io/v1/blocks/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a block with the specified hash.

Parameters

hashstringrequiredpath

Block hash

operationsbooleanfalsequery

Flag indicating whether to include block operations into returned object or not

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get block by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/blocks/{hash}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/blocks/{hash}')
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://xtz-index.nownodes.io/v1/blocks/{hash}')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/blocks/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/blocks/{hash}')
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

{
  "cycle": 0,
  "level": 0,
  "hash": "string",
  "timestamp": "2024-01-15T09:30:00Z",
  "proto": 0,
  "payloadRound": 0,
  "blockRound": 0,
  "validations": 0,
  "deposit": 0,
  "rewardLiquid": 0,
  "rewardStakedOwn": 0,
  "rewardStakedShared": 0,
  "bonusLiquid": 0,
  "bonusStakedOwn": 0,
  "bonusStakedShared": 0,
  "fees": 0,
  "nonceRevealed": true,
  "proposer": {
    "alias": "string",
    "address": "string"
  },
  "producer": {
    "alias": "string",
    "address": "string"
  },
  "software": {
    "version": "string",
    "date": "2024-01-15T09:30:00Z"
  },
  "lbToggle": true,
  "lbToggleEma": 0,
  "aiToggle": true,
  "aiToggleEma": 0,
  "endorsements": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "slots": 0,
      "deposit": 0,
      "rewards": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "preendorsements": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "slots": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "proposals": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "period": {
        "index": 0,
        "epoch": 0,
        "kind": "string",
        "firstLevel": 0,
        "lastLevel": 0
      },
      "proposal": {
        "alias": "string",
        "hash": "string"
      },
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "votingPower": 0,
      "duplicated": true,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "rolls": 0
    }
  ],
  "ballots": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "period": {
        "index": 0,
        "epoch": 0,
        "kind": "string",
        "firstLevel": 0,
        "lastLevel": 0
      },
      "proposal": {
        "alias": "string",
        "hash": "string"
      },
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "votingPower": 0,
      "vote": "string",
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "rolls": 0
    }
  ],
  "activations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "account": {
        "alias": "string",
        "address": "string"
      },
      "balance": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "doubleBaking": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "accusedLevel": 0,
      "slashedLevel": 0,
      "accuser": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "offender": {
        "alias": "string",
        "address": "string"
      },
      "lostStaked": 0,
      "lostUnstaked": 0,
      "lostExternalStaked": 0,
      "lostExternalUnstaked": 0,
      "roundingLoss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "offenderLoss": 0,
      "accuserReward": 0,
      "accuserRewards": 0,
      "offenderLostDeposits": 0,
      "offenderLostRewards": 0,
      "offenderLostFees": 0
    }
  ],
  "doubleEndorsing": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "accusedLevel": 0,
      "slashedLevel": 0,
      "accuser": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "offender": {
        "alias": "string",
        "address": "string"
      },
      "lostStaked": 0,
      "lostUnstaked": 0,
      "lostExternalStaked": 0,
      "lostExternalUnstaked": 0,
      "roundingLoss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "offenderLoss": 0,
      "accuserReward": 0,
      "accuserRewards": 0,
      "offenderLostDeposits": 0,
      "offenderLostRewards": 0,
      "offenderLostFees": 0
    }
  ],
  "doublePreendorsing": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "accusedLevel": 0,
      "slashedLevel": 0,
      "accuser": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "offender": {
        "alias": "string",
        "address": "string"
      },
      "lostStaked": 0,
      "lostUnstaked": 0,
      "lostExternalStaked": 0,
      "lostExternalUnstaked": 0,
      "roundingLoss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "offenderLoss": 0,
      "accuserReward": 0
    }
  ],
  "nonceRevelations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "revealedLevel": 0,
      "revealedCycle": 0,
      "nonce": "string",
      "rewardLiquid": 0,
      "rewardStakedOwn": 0,
      "rewardStakedShared": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "reward": 0,
      "bakerRewards": 0
    }
  ],
  "vdfRevelations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "cycle": 0,
      "solution": "string",
      "proof": "string",
      "rewardLiquid": 0,
      "rewardStakedOwn": 0,
      "rewardStakedShared": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "reward": 0
    }
  ],
  "delegations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "counter": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "senderCodeHash": 0,
      "nonce": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "amount": 0,
      "unstakedPseudotokens": 0,
      "unstakedBalance": 0,
      "unstakedRewards": 0,
      "prevDelegate": {
        "alias": "string",
        "address": "string"
      },
      "newDelegate": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "originations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "counter": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "senderCodeHash": 0,
      "nonce": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "allocationFee": 0,
      "contractBalance": 0,
      "contractManager": {
        "alias": "string",
        "address": "string"
      },
      "contractDelegate": {
        "alias": "string",
        "address": "string"
      },
      "diffs": [
        {
          "bigmap": 0,
          "path": "string",
          "action": "string",
          "content": {
            "hash": "string"
          }
        }
      ],
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "originatedContract": {
        "kind": "string",
        "alias": "string",
        "address": "string",
        "typeHash": 0,
        "codeHash": 0,
        "tzips": [
          "string"
        ]
      },
      "tokenTransfersCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "transactions": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "counter": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "senderCodeHash": 0,
      "nonce": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "allocationFee": 0,
      "target": {
        "alias": "string",
        "address": "string"
      },
      "targetCodeHash": 0,
      "amount": 0,
      "parameter": {
        "entrypoint": "string"
      },
      "diffs": [
        {
          "bigmap": 0,
          "path": "string",
          "action": "string",
          "content": {
            "hash": "string"
          }
        }
      ],
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "hasInternals": true,
      "tokenTransfersCount": 0,
      "ticketTransfersCount": 0,
      "eventsCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "reveals": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "registerConstants": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "address": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "setDepositsLimits": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "limit": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "transferTicketOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "target": {
        "alias": "string",
        "address": "string"
      },
      "ticketer": {
        "alias": "string",
        "address": "string"
      },
      "amount": "string",
      "entrypoint": "string",
      "ticketTransfersCount": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupCommitOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "bond": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupDispatchTicketsOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupFinalizeCommitmentOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupOriginationOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "allocationFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupRejectionOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "committer": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "loss": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupRemoveCommitmentOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupReturnBondOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "bond": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupSubmitBatchOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "increasePaidStorageOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "contract": {
        "alias": "string",
        "address": "string"
      },
      "amount": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "updateConsensusKeyOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "activationCycle": 0,
      "publicKey": "string",
      "publicKeyHash": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "drainDelegateOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "target": {
        "alias": "string",
        "address": "string"
      },
      "amount": 0,
      "fee": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srAddMessagesOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "messagesCount": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srCementOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "commitment": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "inboxLevel": 0,
        "state": "string",
        "hash": "string",
        "ticks": 0,
        "firstLevel": 0,
        "firstTime": "2024-01-15T09:30:00Z"
      },
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srExecuteOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "commitment": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "inboxLevel": 0,
        "state": "string",
        "hash": "string",
        "ticks": 0,
        "firstLevel": 0,
        "firstTime": "2024-01-15T09:30:00Z"
      },
      "errors": [
        {
          "type": "string"
        }
      ],
      "ticketTransfersCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srOriginateOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "pvmKind": "string",
      "kernel": "dGVzdA==",
      "genesisCommitment": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srPublishOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "commitment": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "inboxLevel": 0,
        "state": "string",
        "hash": "string",
        "ticks": 0,
        "firstLevel": 0,
        "firstTime": "2024-01-15T09:30:00Z"
      },
      "bond": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srRecoverBondOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "staker": {
        "alias": "string",
        "address": "string"
      },
      "bond": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srRefuteOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "game": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "initiatorCommitment": {
          "id": 0,
          "initiator": {
            "alias": "string",
            "address": "string"
          },
          "inboxLevel": 0,
          "state": "string",
          "hash": "string",
          "ticks": 0,
          "firstLevel": 0,
          "firstTime": "2024-01-15T09:30:00Z"
        },
        "opponent": {
          "alias": "string",
          "address": "string"
        },
        "opponentCommitment": {
          "id": 0,
          "initiator": {
            "alias": "string",
            "address": "string"
          },
          "inboxLevel": 0,
          "state": "string",
          "hash": "string",
          "ticks": 0,
          "firstLevel": 0,
          "firstTime": "2024-01-15T09:30:00Z"
        },
        "initiatorReward": 0,
        "initiatorLoss": 0,
        "opponentReward": 0,
        "opponentLoss": 0
      },
      "move": "string",
      "gameStatus": "string",
      "dissectionStart": 0,
      "dissectionEnd": 0,
      "dissectionSteps": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "stakingOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "kind": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "amount": 0,
      "pseudotokens": 0,
      "limitOfStakingOverBaking": 0,
      "edgeOfBakingOverStaking": 0,
      "activationCycle": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "migrations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "kind": "string",
      "account": {
        "alias": "string",
        "address": "string"
      },
      "balanceChange": 0,
      "diffs": [
        {
          "bigmap": 0,
          "path": "string",
          "action": "string",
          "content": {
            "hash": "string"
          }
        }
      ],
      "tokenTransfersCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "revelationPenalties": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "missedLevel": 0,
      "loss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "lostReward": 0,
      "lostFees": 0
    }
  ],
  "endorsingRewards": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "expected": 0,
      "rewardLiquid": 0,
      "rewardStakedOwn": 0,
      "rewardStakedShared": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "received": 0
    }
  ],
  "autostakingOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "action": "string",
      "cycle": 0,
      "amount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "quote": {
    "btc": 0,
    "eur": 0,
    "usd": 0,
    "cny": 0,
    "jpy": 0,
    "krw": 0,
    "eth": 0,
    "gbp": 0
  },
  "reward": 0,
  "bonus": 0,
  "priority": 0,
  "baker": {
    "alias": "string",
    "address": "string"
  },
  "lbEscapeVote": true,
  "lbEscapeEma": 0
}

Get block by level

GET

https://xtz-index.nownodes.io/v1/blocks/{level}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a block at the specified level.

Parameters

levelinteger<int32>requiredpath

Block level

operationsbooleanfalsequery

Flag indicating whether to include block operations into returned object or not

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get block by level

curl -X GET 'https://xtz-index.nownodes.io/v1/blocks/{level}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/blocks/{level}')
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://xtz-index.nownodes.io/v1/blocks/{level}')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/blocks/{level}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/blocks/{level}')
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

{
  "cycle": 0,
  "level": 0,
  "hash": "string",
  "timestamp": "2024-01-15T09:30:00Z",
  "proto": 0,
  "payloadRound": 0,
  "blockRound": 0,
  "validations": 0,
  "deposit": 0,
  "rewardLiquid": 0,
  "rewardStakedOwn": 0,
  "rewardStakedShared": 0,
  "bonusLiquid": 0,
  "bonusStakedOwn": 0,
  "bonusStakedShared": 0,
  "fees": 0,
  "nonceRevealed": true,
  "proposer": {
    "alias": "string",
    "address": "string"
  },
  "producer": {
    "alias": "string",
    "address": "string"
  },
  "software": {
    "version": "string",
    "date": "2024-01-15T09:30:00Z"
  },
  "lbToggle": true,
  "lbToggleEma": 0,
  "aiToggle": true,
  "aiToggleEma": 0,
  "endorsements": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "slots": 0,
      "deposit": 0,
      "rewards": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "preendorsements": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "slots": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "proposals": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "period": {
        "index": 0,
        "epoch": 0,
        "kind": "string",
        "firstLevel": 0,
        "lastLevel": 0
      },
      "proposal": {
        "alias": "string",
        "hash": "string"
      },
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "votingPower": 0,
      "duplicated": true,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "rolls": 0
    }
  ],
  "ballots": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "period": {
        "index": 0,
        "epoch": 0,
        "kind": "string",
        "firstLevel": 0,
        "lastLevel": 0
      },
      "proposal": {
        "alias": "string",
        "hash": "string"
      },
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "votingPower": 0,
      "vote": "string",
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "rolls": 0
    }
  ],
  "activations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "account": {
        "alias": "string",
        "address": "string"
      },
      "balance": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "doubleBaking": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "accusedLevel": 0,
      "slashedLevel": 0,
      "accuser": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "offender": {
        "alias": "string",
        "address": "string"
      },
      "lostStaked": 0,
      "lostUnstaked": 0,
      "lostExternalStaked": 0,
      "lostExternalUnstaked": 0,
      "roundingLoss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "offenderLoss": 0,
      "accuserReward": 0,
      "accuserRewards": 0,
      "offenderLostDeposits": 0,
      "offenderLostRewards": 0,
      "offenderLostFees": 0
    }
  ],
  "doubleEndorsing": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "accusedLevel": 0,
      "slashedLevel": 0,
      "accuser": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "offender": {
        "alias": "string",
        "address": "string"
      },
      "lostStaked": 0,
      "lostUnstaked": 0,
      "lostExternalStaked": 0,
      "lostExternalUnstaked": 0,
      "roundingLoss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "offenderLoss": 0,
      "accuserReward": 0,
      "accuserRewards": 0,
      "offenderLostDeposits": 0,
      "offenderLostRewards": 0,
      "offenderLostFees": 0
    }
  ],
  "doublePreendorsing": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "accusedLevel": 0,
      "slashedLevel": 0,
      "accuser": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "offender": {
        "alias": "string",
        "address": "string"
      },
      "lostStaked": 0,
      "lostUnstaked": 0,
      "lostExternalStaked": 0,
      "lostExternalUnstaked": 0,
      "roundingLoss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "offenderLoss": 0,
      "accuserReward": 0
    }
  ],
  "nonceRevelations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "revealedLevel": 0,
      "revealedCycle": 0,
      "nonce": "string",
      "rewardLiquid": 0,
      "rewardStakedOwn": 0,
      "rewardStakedShared": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "reward": 0,
      "bakerRewards": 0
    }
  ],
  "vdfRevelations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "cycle": 0,
      "solution": "string",
      "proof": "string",
      "rewardLiquid": 0,
      "rewardStakedOwn": 0,
      "rewardStakedShared": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "reward": 0
    }
  ],
  "delegations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "counter": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "senderCodeHash": 0,
      "nonce": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "amount": 0,
      "unstakedPseudotokens": 0,
      "unstakedBalance": 0,
      "unstakedRewards": 0,
      "prevDelegate": {
        "alias": "string",
        "address": "string"
      },
      "newDelegate": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "originations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "counter": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "senderCodeHash": 0,
      "nonce": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "allocationFee": 0,
      "contractBalance": 0,
      "contractManager": {
        "alias": "string",
        "address": "string"
      },
      "contractDelegate": {
        "alias": "string",
        "address": "string"
      },
      "diffs": [
        {
          "bigmap": 0,
          "path": "string",
          "action": "string",
          "content": {
            "hash": "string"
          }
        }
      ],
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "originatedContract": {
        "kind": "string",
        "alias": "string",
        "address": "string",
        "typeHash": 0,
        "codeHash": 0,
        "tzips": [
          "string"
        ]
      },
      "tokenTransfersCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "transactions": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "counter": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "senderCodeHash": 0,
      "nonce": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "allocationFee": 0,
      "target": {
        "alias": "string",
        "address": "string"
      },
      "targetCodeHash": 0,
      "amount": 0,
      "parameter": {
        "entrypoint": "string"
      },
      "diffs": [
        {
          "bigmap": 0,
          "path": "string",
          "action": "string",
          "content": {
            "hash": "string"
          }
        }
      ],
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "hasInternals": true,
      "tokenTransfersCount": 0,
      "ticketTransfersCount": 0,
      "eventsCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "reveals": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "registerConstants": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "address": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "setDepositsLimits": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "limit": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "transferTicketOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "target": {
        "alias": "string",
        "address": "string"
      },
      "ticketer": {
        "alias": "string",
        "address": "string"
      },
      "amount": "string",
      "entrypoint": "string",
      "ticketTransfersCount": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupCommitOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "bond": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupDispatchTicketsOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupFinalizeCommitmentOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupOriginationOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "allocationFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupRejectionOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "committer": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "loss": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupRemoveCommitmentOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupReturnBondOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "bond": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupSubmitBatchOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "increasePaidStorageOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "contract": {
        "alias": "string",
        "address": "string"
      },
      "amount": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "updateConsensusKeyOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "activationCycle": 0,
      "publicKey": "string",
      "publicKeyHash": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "drainDelegateOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "target": {
        "alias": "string",
        "address": "string"
      },
      "amount": 0,
      "fee": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srAddMessagesOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "messagesCount": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srCementOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "commitment": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "inboxLevel": 0,
        "state": "string",
        "hash": "string",
        "ticks": 0,
        "firstLevel": 0,
        "firstTime": "2024-01-15T09:30:00Z"
      },
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srExecuteOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "commitment": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "inboxLevel": 0,
        "state": "string",
        "hash": "string",
        "ticks": 0,
        "firstLevel": 0,
        "firstTime": "2024-01-15T09:30:00Z"
      },
      "errors": [
        {
          "type": "string"
        }
      ],
      "ticketTransfersCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srOriginateOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "pvmKind": "string",
      "kernel": "dGVzdA==",
      "genesisCommitment": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srPublishOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "commitment": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "inboxLevel": 0,
        "state": "string",
        "hash": "string",
        "ticks": 0,
        "firstLevel": 0,
        "firstTime": "2024-01-15T09:30:00Z"
      },
      "bond": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srRecoverBondOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "staker": {
        "alias": "string",
        "address": "string"
      },
      "bond": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srRefuteOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "game": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "initiatorCommitment": {
          "id": 0,
          "initiator": {
            "alias": "string",
            "address": "string"
          },
          "inboxLevel": 0,
          "state": "string",
          "hash": "string",
          "ticks": 0,
          "firstLevel": 0,
          "firstTime": "2024-01-15T09:30:00Z"
        },
        "opponent": {
          "alias": "string",
          "address": "string"
        },
        "opponentCommitment": {
          "id": 0,
          "initiator": {
            "alias": "string",
            "address": "string"
          },
          "inboxLevel": 0,
          "state": "string",
          "hash": "string",
          "ticks": 0,
          "firstLevel": 0,
          "firstTime": "2024-01-15T09:30:00Z"
        },
        "initiatorReward": 0,
        "initiatorLoss": 0,
        "opponentReward": 0,
        "opponentLoss": 0
      },
      "move": "string",
      "gameStatus": "string",
      "dissectionStart": 0,
      "dissectionEnd": 0,
      "dissectionSteps": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "stakingOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "kind": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "amount": 0,
      "pseudotokens": 0,
      "limitOfStakingOverBaking": 0,
      "edgeOfBakingOverStaking": 0,
      "activationCycle": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "migrations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "kind": "string",
      "account": {
        "alias": "string",
        "address": "string"
      },
      "balanceChange": 0,
      "diffs": [
        {
          "bigmap": 0,
          "path": "string",
          "action": "string",
          "content": {
            "hash": "string"
          }
        }
      ],
      "tokenTransfersCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "revelationPenalties": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "missedLevel": 0,
      "loss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "lostReward": 0,
      "lostFees": 0
    }
  ],
  "endorsingRewards": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "expected": 0,
      "rewardLiquid": 0,
      "rewardStakedOwn": 0,
      "rewardStakedShared": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "received": 0
    }
  ],
  "autostakingOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "action": "string",
      "cycle": 0,
      "amount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "quote": {
    "btc": 0,
    "eur": 0,
    "usd": 0,
    "cny": 0,
    "jpy": 0,
    "krw": 0,
    "eth": 0,
    "gbp": 0
  },
  "reward": 0,
  "bonus": 0,
  "priority": 0,
  "baker": {
    "alias": "string",
    "address": "string"
  },
  "lbEscapeVote": true,
  "lbEscapeEma": 0
}

Get timestamp by level

GET

https://xtz-index.nownodes.io/v1/blocks/{level}/timestamp

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a timestamp of the block at the specified level.

Parameters

levelinteger<int32>requiredpath

Block level

Response

200OK

Get timestamp by level

curl -X GET 'https://xtz-index.nownodes.io/v1/blocks/{level}/timestamp'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/blocks/{level}/timestamp')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/blocks/{level}/timestamp')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/blocks/{level}/timestamp";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/blocks/{level}/timestamp')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/blocks/{level}/timestamp')
request = Net::HTTP::Get.new(uri)

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

200

"2024-01-15T09:30:00Z"

Get block by timestamp

GET

https://xtz-index.nownodes.io/v1/blocks/{timestamp}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a block closest to the specified timestamp.

Parameters

timestampstring<date-time>requiredpath

Timestamp, e.g. 2020-01-01T00:00:00Z

operationsbooleanfalsequery

Flag indicating whether to include block operations into returned object or not

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get block by timestamp

curl -X GET 'https://xtz-index.nownodes.io/v1/blocks/{timestamp}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/blocks/{timestamp}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/blocks/{timestamp}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/blocks/{timestamp}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/blocks/{timestamp}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/blocks/{timestamp}')
request = Net::HTTP::Get.new(uri)

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

200

{
  "cycle": 0,
  "level": 0,
  "hash": "string",
  "timestamp": "2024-01-15T09:30:00Z",
  "proto": 0,
  "payloadRound": 0,
  "blockRound": 0,
  "validations": 0,
  "deposit": 0,
  "rewardLiquid": 0,
  "rewardStakedOwn": 0,
  "rewardStakedShared": 0,
  "bonusLiquid": 0,
  "bonusStakedOwn": 0,
  "bonusStakedShared": 0,
  "fees": 0,
  "nonceRevealed": true,
  "proposer": {
    "alias": "string",
    "address": "string"
  },
  "producer": {
    "alias": "string",
    "address": "string"
  },
  "software": {
    "version": "string",
    "date": "2024-01-15T09:30:00Z"
  },
  "lbToggle": true,
  "lbToggleEma": 0,
  "aiToggle": true,
  "aiToggleEma": 0,
  "endorsements": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "slots": 0,
      "deposit": 0,
      "rewards": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "preendorsements": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "slots": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "proposals": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "period": {
        "index": 0,
        "epoch": 0,
        "kind": "string",
        "firstLevel": 0,
        "lastLevel": 0
      },
      "proposal": {
        "alias": "string",
        "hash": "string"
      },
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "votingPower": 0,
      "duplicated": true,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "rolls": 0
    }
  ],
  "ballots": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "period": {
        "index": 0,
        "epoch": 0,
        "kind": "string",
        "firstLevel": 0,
        "lastLevel": 0
      },
      "proposal": {
        "alias": "string",
        "hash": "string"
      },
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "votingPower": 0,
      "vote": "string",
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "rolls": 0
    }
  ],
  "activations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "account": {
        "alias": "string",
        "address": "string"
      },
      "balance": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "doubleBaking": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "accusedLevel": 0,
      "slashedLevel": 0,
      "accuser": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "offender": {
        "alias": "string",
        "address": "string"
      },
      "lostStaked": 0,
      "lostUnstaked": 0,
      "lostExternalStaked": 0,
      "lostExternalUnstaked": 0,
      "roundingLoss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "offenderLoss": 0,
      "accuserReward": 0,
      "accuserRewards": 0,
      "offenderLostDeposits": 0,
      "offenderLostRewards": 0,
      "offenderLostFees": 0
    }
  ],
  "doubleEndorsing": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "accusedLevel": 0,
      "slashedLevel": 0,
      "accuser": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "offender": {
        "alias": "string",
        "address": "string"
      },
      "lostStaked": 0,
      "lostUnstaked": 0,
      "lostExternalStaked": 0,
      "lostExternalUnstaked": 0,
      "roundingLoss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "offenderLoss": 0,
      "accuserReward": 0,
      "accuserRewards": 0,
      "offenderLostDeposits": 0,
      "offenderLostRewards": 0,
      "offenderLostFees": 0
    }
  ],
  "doublePreendorsing": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "accusedLevel": 0,
      "slashedLevel": 0,
      "accuser": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "offender": {
        "alias": "string",
        "address": "string"
      },
      "lostStaked": 0,
      "lostUnstaked": 0,
      "lostExternalStaked": 0,
      "lostExternalUnstaked": 0,
      "roundingLoss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "offenderLoss": 0,
      "accuserReward": 0
    }
  ],
  "nonceRevelations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "revealedLevel": 0,
      "revealedCycle": 0,
      "nonce": "string",
      "rewardLiquid": 0,
      "rewardStakedOwn": 0,
      "rewardStakedShared": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "reward": 0,
      "bakerRewards": 0
    }
  ],
  "vdfRevelations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "cycle": 0,
      "solution": "string",
      "proof": "string",
      "rewardLiquid": 0,
      "rewardStakedOwn": 0,
      "rewardStakedShared": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "reward": 0
    }
  ],
  "delegations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "counter": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "senderCodeHash": 0,
      "nonce": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "amount": 0,
      "unstakedPseudotokens": 0,
      "unstakedBalance": 0,
      "unstakedRewards": 0,
      "prevDelegate": {
        "alias": "string",
        "address": "string"
      },
      "newDelegate": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "originations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "counter": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "senderCodeHash": 0,
      "nonce": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "allocationFee": 0,
      "contractBalance": 0,
      "contractManager": {
        "alias": "string",
        "address": "string"
      },
      "contractDelegate": {
        "alias": "string",
        "address": "string"
      },
      "diffs": [
        {
          "bigmap": 0,
          "path": "string",
          "action": "string",
          "content": {
            "hash": "string"
          }
        }
      ],
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "originatedContract": {
        "kind": "string",
        "alias": "string",
        "address": "string",
        "typeHash": 0,
        "codeHash": 0,
        "tzips": [
          "string"
        ]
      },
      "tokenTransfersCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "transactions": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "counter": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "senderCodeHash": 0,
      "nonce": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "allocationFee": 0,
      "target": {
        "alias": "string",
        "address": "string"
      },
      "targetCodeHash": 0,
      "amount": 0,
      "parameter": {
        "entrypoint": "string"
      },
      "diffs": [
        {
          "bigmap": 0,
          "path": "string",
          "action": "string",
          "content": {
            "hash": "string"
          }
        }
      ],
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "hasInternals": true,
      "tokenTransfersCount": 0,
      "ticketTransfersCount": 0,
      "eventsCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "reveals": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "registerConstants": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "address": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "setDepositsLimits": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "limit": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "transferTicketOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "target": {
        "alias": "string",
        "address": "string"
      },
      "ticketer": {
        "alias": "string",
        "address": "string"
      },
      "amount": "string",
      "entrypoint": "string",
      "ticketTransfersCount": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupCommitOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "bond": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupDispatchTicketsOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupFinalizeCommitmentOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupOriginationOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "allocationFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupRejectionOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "committer": {
        "alias": "string",
        "address": "string"
      },
      "reward": 0,
      "loss": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupRemoveCommitmentOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupReturnBondOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "bond": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "txRollupSubmitBatchOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "increasePaidStorageOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "contract": {
        "alias": "string",
        "address": "string"
      },
      "amount": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "updateConsensusKeyOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "activationCycle": 0,
      "publicKey": "string",
      "publicKeyHash": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "drainDelegateOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "hash": "string",
      "delegate": {
        "alias": "string",
        "address": "string"
      },
      "target": {
        "alias": "string",
        "address": "string"
      },
      "amount": 0,
      "fee": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srAddMessagesOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "messagesCount": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srCementOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "commitment": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "inboxLevel": 0,
        "state": "string",
        "hash": "string",
        "ticks": 0,
        "firstLevel": 0,
        "firstTime": "2024-01-15T09:30:00Z"
      },
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srExecuteOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "commitment": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "inboxLevel": 0,
        "state": "string",
        "hash": "string",
        "ticks": 0,
        "firstLevel": 0,
        "firstTime": "2024-01-15T09:30:00Z"
      },
      "errors": [
        {
          "type": "string"
        }
      ],
      "ticketTransfersCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srOriginateOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "storageUsed": 0,
      "bakerFee": 0,
      "storageFee": 0,
      "status": "string",
      "pvmKind": "string",
      "kernel": "dGVzdA==",
      "genesisCommitment": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srPublishOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "commitment": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "inboxLevel": 0,
        "state": "string",
        "hash": "string",
        "ticks": 0,
        "firstLevel": 0,
        "firstTime": "2024-01-15T09:30:00Z"
      },
      "bond": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srRecoverBondOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "staker": {
        "alias": "string",
        "address": "string"
      },
      "bond": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "srRefuteOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "status": "string",
      "rollup": {
        "alias": "string",
        "address": "string"
      },
      "game": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "initiatorCommitment": {
          "id": 0,
          "initiator": {
            "alias": "string",
            "address": "string"
          },
          "inboxLevel": 0,
          "state": "string",
          "hash": "string",
          "ticks": 0,
          "firstLevel": 0,
          "firstTime": "2024-01-15T09:30:00Z"
        },
        "opponent": {
          "alias": "string",
          "address": "string"
        },
        "opponentCommitment": {
          "id": 0,
          "initiator": {
            "alias": "string",
            "address": "string"
          },
          "inboxLevel": 0,
          "state": "string",
          "hash": "string",
          "ticks": 0,
          "firstLevel": 0,
          "firstTime": "2024-01-15T09:30:00Z"
        },
        "initiatorReward": 0,
        "initiatorLoss": 0,
        "opponentReward": 0,
        "opponentLoss": 0
      },
      "move": "string",
      "gameStatus": "string",
      "dissectionStart": 0,
      "dissectionEnd": 0,
      "dissectionSteps": 0,
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "stakingOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "hash": "string",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "counter": 0,
      "gasLimit": 0,
      "gasUsed": 0,
      "storageLimit": 0,
      "bakerFee": 0,
      "kind": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "amount": 0,
      "pseudotokens": 0,
      "limitOfStakingOverBaking": 0,
      "edgeOfBakingOverStaking": 0,
      "activationCycle": 0,
      "status": "string",
      "errors": [
        {
          "type": "string"
        }
      ],
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "migrations": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "kind": "string",
      "account": {
        "alias": "string",
        "address": "string"
      },
      "balanceChange": 0,
      "diffs": [
        {
          "bigmap": 0,
          "path": "string",
          "action": "string",
          "content": {
            "hash": "string"
          }
        }
      ],
      "tokenTransfersCount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "revelationPenalties": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "missedLevel": 0,
      "loss": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "lostReward": 0,
      "lostFees": 0
    }
  ],
  "endorsingRewards": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "block": "string",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "expected": 0,
      "rewardLiquid": 0,
      "rewardStakedOwn": 0,
      "rewardStakedShared": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      },
      "received": 0
    }
  ],
  "autostakingOps": [
    {
      "type": "string",
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "baker": {
        "alias": "string",
        "address": "string"
      },
      "action": "string",
      "cycle": 0,
      "amount": 0,
      "quote": {
        "btc": 0,
        "eur": 0,
        "usd": 0,
        "cny": 0,
        "jpy": 0,
        "krw": 0,
        "eth": 0,
        "gbp": 0
      }
    }
  ],
  "quote": {
    "btc": 0,
    "eur": 0,
    "usd": 0,
    "cny": 0,
    "jpy": 0,
    "krw": 0,
    "eth": 0,
    "gbp": 0
  },
  "reward": 0,
  "bonus": 0,
  "priority": 0,
  "baker": {
    "alias": "string",
    "address": "string"
  },
  "lbEscapeVote": true,
  "lbEscapeEma": 0
}

Get level by timestamp

GET

https://xtz-index.nownodes.io/v1/blocks/{timestamp}/level

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a level of the block closest to the specified timestamp.

Parameters

timestampstring<date-time>requiredpath

Timestamp, e.g. 2020-01-01T00:00:00Z

Response

200OK

Get level by timestamp

curl -X GET 'https://xtz-index.nownodes.io/v1/blocks/{timestamp}/level'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/blocks/{timestamp}/level')
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://xtz-index.nownodes.io/v1/blocks/{timestamp}/level')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/blocks/{timestamp}/level')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/blocks/{timestamp}/level')
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

Commitments

Get commitment by blinded address

GET

https://xtz-index.nownodes.io/v1/commitments/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a commitment with the specified blinded address.

Parameters

addressstringrequiredpath

Blinded address (starting with btz)

Response

200OK

Get commitment by blinded address

curl -X GET 'https://xtz-index.nownodes.io/v1/commitments/{address}'

const response = await fetch('https://xtz-index.nownodes.io/v1/commitments/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/commitments/{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://xtz-index.nownodes.io/v1/commitments/{address}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/commitments/{address}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/commitments/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/commitments/{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

{
  "address": "string",
  "balance": 0,
  "activated": true,
  "activationLevel": 0,
  "activationTime": "2024-01-15T09:30:00Z",
  "activatedAccount": {
    "alias": "string",
    "address": "string"
  }
}

Get commitments

GET

https://xtz-index.nownodes.io/v1/commitments

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of commitments.

Parameters

activatedboolean | nullquery

Filters commitments by activation status

activationLevelInt32NullParameter | nullquery

Filters commitments by activation level

balanceInt64Parameter | nullquery

Filters commitments by activated balance

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts delegators by specified field. Supported fields: id (default), balance, activationLevel.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get commitments

curl -X GET 'https://xtz-index.nownodes.io/v1/commitments'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/commitments')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/commitments')
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": "string",
    "balance": 0,
    "activated": true,
    "activationLevel": 0,
    "activationTime": "2024-01-15T09:30:00Z",
    "activatedAccount": {
      "alias": "string",
      "address": "string"
    }
  }
]

Get commitments count

GET

https://xtz-index.nownodes.io/v1/commitments/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a number of commitments.

Parameters

activatedboolean | nullquery

Filters commitments by activation status

balanceInt64Parameter | nullquery

Filters commitments by activated balance

Response

200OK

Get commitments count

curl -X GET 'https://xtz-index.nownodes.io/v1/commitments/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/commitments/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/commitments/count')
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://xtz-index.nownodes.io/v1/commitments/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/commitments/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/commitments/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/commitments/count')
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

Constants

Get global constants

GET

https://xtz-index.nownodes.io/v1/constants

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of global constants.

Parameters

addressExpressionParameter | nullquery

Filters constants by global address (starts with expr..).

creationLevelInt32Parameter | nullquery

Filters constants by creation level.

creationTimeTimestampParameter | nullquery

Filters constants by creation time.

creatorAccountParameter | nullquery

Filters constants by creator.

refsInt32Parameter | nullquery

Filters constants by number of refs.

sizeInt32Parameter | nullquery

Filters constants by size in bytes.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts delegators by specified field. Supported fields: id (default), creationLevel, size, refs.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

formatinteger<int32>[0, 2]0query

Constant value format (0 - micheline, 1 - michelson, 2 - bytes (base64))

Response

200OK

Get global constants

curl -X GET 'https://xtz-index.nownodes.io/v1/constants'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/constants')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/constants')
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": "string",
    "size": 0,
    "refs": 0,
    "creator": {
      "alias": "string",
      "address": "string"
    },
    "creationLevel": 0,
    "creationTime": "2024-01-15T09:30:00Z"
  }
]

Get global constant by address

GET

https://xtz-index.nownodes.io/v1/constants/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns global constant with specified address (expression hash).

Parameters

addressstringrequiredpath

Global address (starts with expr..)

formatinteger<int32>[0, 2]0query

Constant value format (0 - micheline, 1 - michelson, 2 - bytes (base64))

Response

200OK

Get global constant by address

curl -X GET 'https://xtz-index.nownodes.io/v1/constants/{address}'

const response = await fetch('https://xtz-index.nownodes.io/v1/constants/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/constants/{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://xtz-index.nownodes.io/v1/constants/{address}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/constants/{address}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/constants/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/constants/{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

{
  "address": "string",
  "size": 0,
  "refs": 0,
  "creator": {
    "alias": "string",
    "address": "string"
  },
  "creationLevel": 0,
  "creationTime": "2024-01-15T09:30:00Z"
}

Get global constants count

GET

https://xtz-index.nownodes.io/v1/constants/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a number of global constants.

Parameters

refsInt32Parameter | nullquery

Filters constants by number of refs.

Response

200OK

Get global constants count

curl -X GET 'https://xtz-index.nownodes.io/v1/constants/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/constants/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/constants/count')
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://xtz-index.nownodes.io/v1/constants/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/constants/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/constants/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/constants/count')
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

Contracts

Get contracts

GET

https://xtz-index.nownodes.io/v1/contracts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of contract accounts.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

addressAddressParameter | nullquery

Filter by address.
Click on the parameter to expand more details.

kindContractKindParameter | nullquery

Filter by kind (delegator_contract, smart_contract, or asset).
Click on the parameter to expand more details.

tzipsContractTagsParameter | nullquery

Filter by tzips (fa1, fa12, or fa2).
Click on the parameter to expand more details.

balanceInt64Parameter | nullquery

Filter by balance.
Click on the parameter to expand more details.

creatorAccountParameter | nullquery

Filter by creator.
Click on the parameter to expand more details.

managerAccountParameter | nullquery

Filter by manager.
Click on the parameter to expand more details.

delegateAccountParameter | nullquery

Filter by delegate.
Click on the parameter to expand more details.

firstActivityInt32Parameter | nullquery

Filter by level of the block where the contract was first seen.
Click on the parameter to expand more details.

firstActivityTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the contract was first seen.
Click on the parameter to expand more details.

lastActivityInt32Parameter | nullquery

Filter by level of the block where the contract was last seen.
Click on the parameter to expand more details.

lastActivityTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the contract was last seen.
Click on the parameter to expand more details.

typeHashInt32Parameter | nullquery

Filter by 32-bit hash of contract parameter and storage types (helpful for searching similar contracts).
Click on the parameter to expand more details.

codeHashInt32Parameter | nullquery

Filter by 32-bit hash of contract code (helpful for searching same contracts).
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

includeStoragebooleanfalsequery

Specifies whether to include contract storage into response.

Response

200OK

Get contracts

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/contracts";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "type": "string",
    "id": 0,
    "address": "string",
    "kind": "string",
    "tzips": [
      "string"
    ],
    "alias": "string",
    "balance": 0,
    "creator": {
      "alias": "string",
      "address": "string"
    },
    "manager": {
      "alias": "string",
      "address": "string",
      "publicKey": "string"
    },
    "delegate": {
      "alias": "string",
      "address": "string",
      "active": true
    },
    "delegationLevel": 0,
    "delegationTime": "2024-01-15T09:30:00Z",
    "numContracts": 0,
    "tokensCount": 0,
    "activeTokensCount": 0,
    "tokenBalancesCount": 0,
    "tokenTransfersCount": 0,
    "ticketsCount": 0,
    "activeTicketsCount": 0,
    "ticketBalancesCount": 0,
    "ticketTransfersCount": 0,
    "numDelegations": 0,
    "numOriginations": 0,
    "numTransactions": 0,
    "numReveals": 0,
    "numMigrations": 0,
    "transferTicketCount": 0,
    "increasePaidStorageCount": 0,
    "eventsCount": 0,
    "firstActivity": 0,
    "firstActivityTime": "2024-01-15T09:30:00Z",
    "lastActivity": 0,
    "lastActivityTime": "2024-01-15T09:30:00Z",
    "typeHash": 0,
    "codeHash": 0
  }
]

Get contracts count

GET

https://xtz-index.nownodes.io/v1/contracts/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a number of contract accounts.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

addressAddressParameter | nullquery

Filter by address.
Click on the parameter to expand more details.

kindContractKindParameter | nullquery

Filter by kind (delegator_contract, smart_contract, or asset).
Click on the parameter to expand more details.

tzipsContractTagsParameter | nullquery

Filter by tzips (fa1, fa12, or fa2).
Click on the parameter to expand more details.

balanceInt64Parameter | nullquery

Filter by balance.
Click on the parameter to expand more details.

creatorAccountParameter | nullquery

Filter by creator.
Click on the parameter to expand more details.

managerAccountParameter | nullquery

Filter by manager.
Click on the parameter to expand more details.

delegateAccountParameter | nullquery

Filter by delegate.
Click on the parameter to expand more details.

firstActivityInt32Parameter | nullquery

Filter by level of the block where the contract was first seen.
Click on the parameter to expand more details.

firstActivityTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the contract was first seen.
Click on the parameter to expand more details.

lastActivityInt32Parameter | nullquery

Filter by level of the block where the contract was last seen.
Click on the parameter to expand more details.

lastActivityTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the contract was last seen.
Click on the parameter to expand more details.

typeHashInt32Parameter | nullquery

Filter by 32-bit hash of contract parameter and storage types (helpful for searching similar contracts).
Click on the parameter to expand more details.

codeHashInt32Parameter | nullquery

Filter by 32-bit hash of contract code (helpful for searching same contracts).
Click on the parameter to expand more details.

Response

200OK

Get contracts count

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/count')
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://xtz-index.nownodes.io/v1/contracts/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/count')
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

Get contract by address

GET

https://xtz-index.nownodes.io/v1/contracts/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a contract account with the specified address.

Parameters

addressstringrequiredpath

Contract address (starting with KT)

legacybooleantruequery

If true (by default), the metadata field will contain tzkt profile info, or TZIP-16 metadata otherwise. This is a part of a deprecation mechanism, allowing to switch to new functionality smoothly.

Response

200OK

Get contract by address

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{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://xtz-index.nownodes.io/v1/contracts/{address}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{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

{
  "type": "string",
  "id": 0,
  "address": "string",
  "kind": "string",
  "tzips": [
    "string"
  ],
  "alias": "string",
  "balance": 0,
  "creator": {
    "alias": "string",
    "address": "string"
  },
  "manager": {
    "alias": "string",
    "address": "string",
    "publicKey": "string"
  },
  "delegate": {
    "alias": "string",
    "address": "string",
    "active": true
  },
  "delegationLevel": 0,
  "delegationTime": "2024-01-15T09:30:00Z",
  "numContracts": 0,
  "tokensCount": 0,
  "activeTokensCount": 0,
  "tokenBalancesCount": 0,
  "tokenTransfersCount": 0,
  "ticketsCount": 0,
  "activeTicketsCount": 0,
  "ticketBalancesCount": 0,
  "ticketTransfersCount": 0,
  "numDelegations": 0,
  "numOriginations": 0,
  "numTransactions": 0,
  "numReveals": 0,
  "numMigrations": 0,
  "transferTicketCount": 0,
  "increasePaidStorageCount": 0,
  "eventsCount": 0,
  "firstActivity": 0,
  "firstActivityTime": "2024-01-15T09:30:00Z",
  "lastActivity": 0,
  "lastActivityTime": "2024-01-15T09:30:00Z",
  "typeHash": 0,
  "codeHash": 0
}

Get same contracts

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/same

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns contracts which have the same script as the specified one. Note, contract scripts are compared by 32-bit hash, so in very rare cases there may be collisions.

Parameters

addressstringrequiredpath

Contract address (starting with KT)

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

includeStoragebooleanfalsequery

Specifies whether to include contract storage value in response.

Response

200OK

Get same contracts

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/same'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/same', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/same')
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://xtz-index.nownodes.io/v1/contracts/{address}/same')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/same', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/same')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/same')
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

[
  {
    "type": "string",
    "id": 0,
    "address": "string",
    "kind": "string",
    "tzips": [
      "string"
    ],
    "alias": "string",
    "balance": 0,
    "creator": {
      "alias": "string",
      "address": "string"
    },
    "manager": {
      "alias": "string",
      "address": "string",
      "publicKey": "string"
    },
    "delegate": {
      "alias": "string",
      "address": "string",
      "active": true
    },
    "delegationLevel": 0,
    "delegationTime": "2024-01-15T09:30:00Z",
    "numContracts": 0,
    "tokensCount": 0,
    "activeTokensCount": 0,
    "tokenBalancesCount": 0,
    "tokenTransfersCount": 0,
    "ticketsCount": 0,
    "activeTicketsCount": 0,
    "ticketBalancesCount": 0,
    "ticketTransfersCount": 0,
    "numDelegations": 0,
    "numOriginations": 0,
    "numTransactions": 0,
    "numReveals": 0,
    "numMigrations": 0,
    "transferTicketCount": 0,
    "increasePaidStorageCount": 0,
    "eventsCount": 0,
    "firstActivity": 0,
    "firstActivityTime": "2024-01-15T09:30:00Z",
    "lastActivity": 0,
    "lastActivityTime": "2024-01-15T09:30:00Z",
    "typeHash": 0,
    "codeHash": 0
  }
]

Get similar contracts

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/similar

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns contracts which have the same interface (parameter and storage types) as the specified one. Note, contract parameter and storage types are compared by 32-bit hash, so in very rare cases there may be collisions.

Parameters

addressstringrequiredpath

Contract address (starting with KT)

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

includeStoragebooleanfalsequery

Specifies whether to include contract storage value in response.

Response

200OK

Get similar contracts

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/similar'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/similar', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/similar')
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://xtz-index.nownodes.io/v1/contracts/{address}/similar')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/similar', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/similar')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/similar')
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

[
  {
    "type": "string",
    "id": 0,
    "address": "string",
    "kind": "string",
    "tzips": [
      "string"
    ],
    "alias": "string",
    "balance": 0,
    "creator": {
      "alias": "string",
      "address": "string"
    },
    "manager": {
      "alias": "string",
      "address": "string",
      "publicKey": "string"
    },
    "delegate": {
      "alias": "string",
      "address": "string",
      "active": true
    },
    "delegationLevel": 0,
    "delegationTime": "2024-01-15T09:30:00Z",
    "numContracts": 0,
    "tokensCount": 0,
    "activeTokensCount": 0,
    "tokenBalancesCount": 0,
    "tokenTransfersCount": 0,
    "ticketsCount": 0,
    "activeTicketsCount": 0,
    "ticketBalancesCount": 0,
    "ticketTransfersCount": 0,
    "numDelegations": 0,
    "numOriginations": 0,
    "numTransactions": 0,
    "numReveals": 0,
    "numMigrations": 0,
    "transferTicketCount": 0,
    "increasePaidStorageCount": 0,
    "eventsCount": 0,
    "firstActivity": 0,
    "firstActivityTime": "2024-01-15T09:30:00Z",
    "lastActivity": 0,
    "lastActivityTime": "2024-01-15T09:30:00Z",
    "typeHash": 0,
    "codeHash": 0
  }
]

Get contract code

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/code

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a code of the specified contract.

Parameters

addressstringrequiredpath

Contract address (starting with KT)

levelinteger<int32>0query

Level at which contract code should be taken. If 0 or not specified, the current value will be returned.

formatinteger<int32>[0, 2]0query

Code format (0 - micheline, 1 - michelson, 2 - bytes (base64))

Response

200OK

Get contract code

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/code'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/code', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{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://xtz-index.nownodes.io/v1/contracts/{address}/code')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/code', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/code')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{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

"<binary>"

Get JSON Schema [2020-12] interface for the contract

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/interface

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns standard JSON Schema for contract storage, entrypoints, and Big_map entries.

Parameters

addressstringrequiredpath

Contract address

Response

200OK

Get JSON Schema [2020-12] interface for the contract

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/interface'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/interface', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/interface')
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://xtz-index.nownodes.io/v1/contracts/{address}/interface')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/interface', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/interface')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/interface')
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

{
  "entrypoints": [
    {
      "name": "string"
    }
  ],
  "bigMaps": [
    {
      "path": "string",
      "name": "string"
    }
  ],
  "events": [
    {
      "tag": "string"
    }
  ]
}

Get contract entrypoints

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns entrypoints of the specified contract.

Parameters

addressstringrequiredpath

Contract address (starting with KT)

allbooleanfalsequery

If true, returns all entrypoints, including unused ones. Unused means that the entrypoint can be normalized to a more specific one. For example here (or %entry1 (unit %entry2) (nat %entry3)) the %entry1 is unused entrypoint because it can be normalized to %entry2 or %entry3

jsonbooleantruequery

Include parameters schema in human-readable JSON format

michelinebooleanfalsequery

Include parameters schema in micheline format

michelsonbooleanfalsequery

Include parameters schema in michelson format

Response

200OK

Get contract entrypoints

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints')
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://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints')
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

[
  {
    "name": "string",
    "michelineParameters": {
      "type": 0
    },
    "michelsonParameters": "string",
    "unused": true
  }
]

Get entrypoint by name

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns contract's entrypoint with specified name.

Parameters

addressstringrequiredpath

Contract address (starting with KT)

namestringrequiredpath

Entrypoint name

jsonbooleantruequery

Include parameters schema in human-readable JSON format

michelinebooleanfalsequery

Include parameters schema in micheline format

michelsonbooleanfalsequery

Include parameters schema in michelson format

Response

200OK

Get entrypoint by name

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}')
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://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}')
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

{
  "name": "string",
  "michelineParameters": {
    "type": 0
  },
  "michelsonParameters": "string",
  "unused": true
}

Get contract views

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/views

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all views of the specified contract.

Parameters

addressstringrequiredpath

Contract address (starting with KT)

jsonbooleantruequery

Include parameter and return types in human-readable JSON format

michelinebooleanfalsequery

Include parameter and return types in micheline format

michelsonbooleanfalsequery

Include parameter and return types in michelson format

Response

200OK

Get contract views

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/views'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/views', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/views')
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://xtz-index.nownodes.io/v1/contracts/{address}/views')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/views', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/views')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/views')
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

[
  {
    "name": "string",
    "michelineParameterType": {
      "type": 0
    },
    "michelineReturnType": {
      "type": 0
    },
    "michelsonParameterType": "string",
    "michelsonReturnType": "string"
  }
]

Get view by name

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/views/{name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns contract view with specified name.

Parameters

addressstringrequiredpath

Contract address (starting with KT)

namestringrequiredpath

View name

jsonbooleantruequery

Include parameter and return types in human-readable JSON format

michelinebooleanfalsequery

Include parameter and return types in micheline format

michelsonbooleanfalsequery

Include parameter and return types in michelson format

Response

200OK

Get view by name

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/views/{name}'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/views/{name}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/views/{name}')
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://xtz-index.nownodes.io/v1/contracts/{address}/views/{name}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/views/{name}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/views/{name}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/views/{name}')
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

{
  "name": "string",
  "michelineParameterType": {
    "type": 0
  },
  "michelineReturnType": {
    "type": 0
  },
  "michelsonParameterType": "string",
  "michelsonReturnType": "string"
}

Build entrypoint parameters

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns micheline parameters converted from its JSON representation.

Parameters

addressstringrequiredpath

Contract address

namestringrequiredpath

Entrypoint name

valuestring | nullquery

Json parameters

Response

200OK

Build entrypoint parameters

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build')
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://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build";
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://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build')
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

"<binary>"

Build entrypoint parameters

POST

https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns micheline parameters converted from its JSON representation.

Body

application/json

Json parameters

any

Parameters

addressstringrequiredpath

Contract address

namestringrequiredpath

Entrypoint name

Response

200OK

Build entrypoint parameters

curl -X POST 'https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build' \
  -H 'Content-Type: application/json'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'

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

import requests

response = requests.post('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build', headers={'Content-Type': 'application/json'})
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
});

const data = await response.json();

import requests

response = requests.post('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build', headers={'Content-Type': 'application/json'})
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/entrypoints/{name}/build')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'

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

200

"<binary>"

Get contract storage

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/storage

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns contract storage value in JSON format.

Parameters

addressstringrequiredpath

Contract address

levelinteger<int32>0query

Level at which storage value should be taken. If 0 or not specified, the current value will be returned.

pathstring | nullquery

Path in the JSON value (point-separated list of field names, e.g. path=settings.refund_time to return

Response

200OK

Get contract storage

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/storage'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage')
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://xtz-index.nownodes.io/v1/contracts/{address}/storage')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/storage')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage')
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

"<binary>"

Get contract storage schema

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/storage/schema

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns JSON schema of the contract storage.

Parameters

addressstringrequiredpath

Contract address

levelinteger<int32>0query

Level at which storage schema should be taken. If 0 or not specified, the current schema will be returned.

Response

200OK

Get contract storage schema

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/storage/schema'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/schema', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/schema')
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://xtz-index.nownodes.io/v1/contracts/{address}/storage/schema')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/schema', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/schema')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/schema')
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

"<binary>"

Get contract storage history

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/storage/history

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns contract storage historical values.

Parameters

addressstringrequiredpath

Contract address

lastIdinteger<int32>0query

Id of the last item received (for pagination)

limitinteger<int32>[0, 1000]10query

Maximum number of items to return

Response

200OK

Get contract storage history

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/storage/history'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/history', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/history')
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://xtz-index.nownodes.io/v1/contracts/{address}/storage/history')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/history', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/history')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/history')
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": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "operation": {
      "type": "string",
      "hash": "string",
      "counter": 0,
      "nonce": 0,
      "parameter": {
        "entrypoint": "string"
      }
    }
  }
]

Get raw contract storage

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns raw contract storage value in micheline format.

Parameters

addressstringrequiredpath

Contract address

levelinteger<int32>0query

Level at which storage value should be taken. If 0 or not specified, the current value will be returned.

Response

200OK

Get raw contract storage

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw')
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://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw')
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

{
  "type": 0
}

Get raw contract storage schema

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/schema

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns micheline schema (type) of the contract storage.

Parameters

addressstringrequiredpath

Contract address

levelinteger<int32>0query

Level at which storage schema should be taken. If 0 or not specified, the current schema will be returned.

Response

200OK

Get raw contract storage schema

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/schema'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/schema', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/schema')
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://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/schema')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/schema', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/schema";
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://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/schema', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/schema')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/schema')
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

{
  "type": 0
}

Get raw contract storage history

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/history

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns raw contract storage historical values.

Parameters

addressstringrequiredpath

Contract address

lastIdinteger<int32>0query

Id of the last item received (for pagination)

limitinteger<int32>[0, 1000]10query

Maximum number of items to return

Response

200OK

Get raw contract storage history

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/history'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/history', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/history')
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://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/history')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/history', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/history";
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://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/history', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/history')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/storage/raw/history')
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": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "operation": {
      "type": "string",
      "hash": "string",
      "counter": 0,
      "nonce": 0,
      "parameter": {
        "entrypoint": "string"
      }
    }
  }
]

Get contract bigmaps

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all active bigmaps allocated in the contract storage.

Parameters

addressstringrequiredpath

Contract address

tagsBigMapTagsParameter | nullquery

Filters bigmaps tags (metadata, token_metadata, ledger).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts bigmaps by specified field. Supported fields: id (default), firstLevel, lastLevel, totalKeys, activeKeys, updates.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the bigmap key and value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get contract bigmaps

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps')
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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps')
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

[
  {
    "ptr": 0,
    "contract": {
      "alias": "string",
      "address": "string"
    },
    "path": "string",
    "tags": [
      "string"
    ],
    "active": true,
    "firstLevel": 0,
    "lastLevel": 0,
    "totalKeys": 0,
    "activeKeys": 0,
    "updates": 0
  }
]

Get bigmap by name

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns contract bigmap with the specified name or storage path.

Parameters

addressstringrequiredpath

Contract address

namestringrequiredpath

Bigmap name is the last piece of the bigmap storage path. For example, if the storage path is ledger or assets.ledger, then the name is ledger. If there are multiple bigmaps with the same name, for example assets.ledger and tokens.ledger, you can specify the full path.

michelineMichelineFormatJsonquery

Format of the bigmap key and value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get bigmap by name

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}')
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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}')
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

{
  "ptr": 0,
  "contract": {
    "alias": "string",
    "address": "string"
  },
  "path": "string",
  "tags": [
    "string"
  ],
  "active": true,
  "firstLevel": 0,
  "lastLevel": 0,
  "totalKeys": 0,
  "activeKeys": 0,
  "updates": 0
}

Get bigmap keys

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns keys of a contract bigmap with the specified name.

Parameters

addressstringrequiredpath

Contract address

namestringrequiredpath

activeboolean | nullquery

Filters keys by status: true - active, false - removed.

keyJsonParameter | nullquery

valueJsonParameter | nullquery

lastLevelInt32Parameter | nullquery

Filters bigmap keys by the last update level.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts bigmap keys by specified field. Supported fields: id (default), firstLevel, lastLevel, updates.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the bigmap key and value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get bigmap keys

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys')
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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys";
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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys')
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": 0,
    "active": true,
    "hash": "string",
    "firstLevel": 0,
    "lastLevel": 0,
    "updates": 0
  }
]

Get bigmap key

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the specified bigmap key.

Parameters

addressstringrequiredpath

Contract address

namestringrequiredpath

keystringrequiredpath

Either a key hash (expr123...) or a plain value (foo...). Even if the key is complex (an object or an array), you can specify it as is, for example, /keys/{"address":"tz123","nat":"123"}.

michelineMichelineFormatJsonquery

Format of the bigmap key and value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get bigmap key

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{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

{
  "id": 0,
  "active": true,
  "hash": "string",
  "firstLevel": 0,
  "lastLevel": 0,
  "updates": 0
}

Get bigmap key updates

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}/updates

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns updates history for the specified bigmap key.

Parameters

addressstringrequiredpath

Contract address

namestringrequiredpath

keystringrequiredpath

Either a key hash (expr123...) or a plain value (foo...). Even if the key is complex (an object or an array), you can specify it as is, for example, /keys/{"address":"tz123","nat":"123"}.

sortSortParameter | nullquery

Sorts bigmap updates by specified field. Supported fields: id (default).

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the key value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get bigmap key updates

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}/updates'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}/updates', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}/updates')
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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}/updates')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}/updates', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}/updates";
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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}/updates', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}/updates')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/keys/{key}/updates')
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": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "action": "string"
  }
]

Get historical keys

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of bigmap keys at the specific block.

Parameters

addressstringrequiredpath

Contract address

namestringrequiredpath

levelinteger<int32>requiredpath

Level of the block at which you want to get bigmap keys

activeboolean | nullquery

Filters keys by status: true - active, false - removed.

keyJsonParameter | nullquery

valueJsonParameter | nullquery

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts bigmap keys by specified field. Supported fields: id (default).

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the bigmap key and value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get historical keys

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}')
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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}";
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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}')
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": 0,
    "active": true,
    "hash": "string"
  }
]

Get historical key

GET

https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}/{key}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the specified bigmap key at the specific block.

Parameters

addressstringrequiredpath

Contract address

namestringrequiredpath

levelinteger<int32>requiredpath

Level of the block at which you want to get bigmap key

keystringrequiredpath

Either a key hash (expr123...) or a plain value (foo...). Even if the key is complex (an object or an array), you can specify it as is, for example, /keys/{"address":"tz123","nat":"123"}.

michelineMichelineFormatJsonquery

Format of the bigmap key and value: 0 - JSON, 1 - JSON string, 2 - Micheline, 3 - Micheline string

Response

200OK

Get historical key

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}/{key}'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}/{key}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}/{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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}/{key}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}/{key}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}/{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://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}/{key}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}/{key}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/{address}/bigmaps/{name}/historical_keys/{level}/{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

{
  "id": 0,
  "active": true,
  "hash": "string"
}

Cycles

Get cycles count

GET

https://xtz-index.nownodes.io/v1/cycles/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of cycles, including future cycles.

Response

200OK

Get cycles count

curl -X GET 'https://xtz-index.nownodes.io/v1/cycles/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/cycles/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/cycles/count')
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://xtz-index.nownodes.io/v1/cycles/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/cycles/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/cycles/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/cycles/count')
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

Get cycles

GET

https://xtz-index.nownodes.io/v1/cycles

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of cycles, including future cycles.

Parameters

snapshotIndexInt32Parameter | nullquery

Filters cycles by snapshot index (0..15)

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts cycles by specified field. Supported fields: index (default, desc).

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get cycles

curl -X GET 'https://xtz-index.nownodes.io/v1/cycles'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/cycles')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/cycles')
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

[
  {
    "index": 0,
    "firstLevel": 0,
    "startTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "endTime": "2024-01-15T09:30:00Z",
    "snapshotIndex": 0,
    "snapshotLevel": 0,
    "randomSeed": "string",
    "totalBakers": 0,
    "totalBakingPower": 0,
    "blockReward": 0,
    "blockBonusPerSlot": 0,
    "endorsementRewardPerSlot": 0,
    "nonceRevelationReward": 0,
    "vdfRevelationReward": 0,
    "lbSubsidy": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "totalStaking": 0,
    "totalDelegators": 0,
    "totalDelegated": 0,
    "selectedBakers": 0,
    "selectedStake": 0,
    "totalRolls": 0
  }
]

Get cycle by index

GET

https://xtz-index.nownodes.io/v1/cycles/{index}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a cycle at the specified index.

Parameters

indexinteger<int32>requiredpath

Cycle index starting from zero

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get cycle by index

curl -X GET 'https://xtz-index.nownodes.io/v1/cycles/{index}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/cycles/{index}')
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://xtz-index.nownodes.io/v1/cycles/{index}')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/cycles/{index}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/cycles/{index}')
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

{
  "index": 0,
  "firstLevel": 0,
  "startTime": "2024-01-15T09:30:00Z",
  "lastLevel": 0,
  "endTime": "2024-01-15T09:30:00Z",
  "snapshotIndex": 0,
  "snapshotLevel": 0,
  "randomSeed": "string",
  "totalBakers": 0,
  "totalBakingPower": 0,
  "blockReward": 0,
  "blockBonusPerSlot": 0,
  "endorsementRewardPerSlot": 0,
  "nonceRevelationReward": 0,
  "vdfRevelationReward": 0,
  "lbSubsidy": 0,
  "quote": {
    "btc": 0,
    "eur": 0,
    "usd": 0,
    "cny": 0,
    "jpy": 0,
    "krw": 0,
    "eth": 0,
    "gbp": 0
  },
  "totalStaking": 0,
  "totalDelegators": 0,
  "totalDelegated": 0,
  "selectedBakers": 0,
  "selectedStake": 0,
  "totalRolls": 0
}

Delegates

Get delegates

GET

https://xtz-index.nownodes.io/v1/delegates

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of delegate accounts.

Parameters

activeBoolParameter | nullquery

Delegate status to filter by (true - only active, false - only deactivated, undefined - all delegates)

lastActivityInt32Parameter | nullquery

Filters delegates by last activity level (where the delegate was updated)

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts delegators by specified field. Supported fields: id (default), activationLevel, deactivationLevel, stakingBalance, balance, numDelegators.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get delegates

curl -X GET 'https://xtz-index.nownodes.io/v1/delegates'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/delegates')
data = response.json()

require 'net/http'
require 'json'

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

200

[
  {
    "type": "string",
    "id": 0,
    "address": "string",
    "active": true,
    "alias": "string",
    "publicKey": "string",
    "revealed": true,
    "balance": 0,
    "rollupBonds": 0,
    "smartRollupBonds": 0,
    "stakedBalance": 0,
    "stakedPseudotokens": 0,
    "unstakedBalance": 0,
    "unstakedBaker": {
      "alias": "string",
      "address": "string"
    },
    "externalStakedBalance": 0,
    "externalUnstakedBalance": 0,
    "totalStakedBalance": 0,
    "issuedPseudotokens": 0,
    "stakersCount": 0,
    "lostBalance": 0,
    "frozenDepositLimit": 0,
    "limitOfStakingOverBaking": 0,
    "edgeOfBakingOverStaking": 0,
    "counter": 0,
    "activationLevel": 0,
    "activationTime": "2024-01-15T09:30:00Z",
    "deactivationLevel": 0,
    "deactivationTime": "2024-01-15T09:30:00Z",
    "stakingBalance": 0,
    "delegatedBalance": 0,
    "numContracts": 0,
    "rollupsCount": 0,
    "smartRollupsCount": 0,
    "activeTokensCount": 0,
    "tokenBalancesCount": 0,
    "tokenTransfersCount": 0,
    "activeTicketsCount": 0,
    "ticketBalancesCount": 0,
    "ticketTransfersCount": 0,
    "numDelegators": 0,
    "numBlocks": 0,
    "numEndorsements": 0,
    "numPreendorsements": 0,
    "numBallots": 0,
    "numProposals": 0,
    "numActivations": 0,
    "numDoubleBaking": 0,
    "numDoubleEndorsing": 0,
    "numDoublePreendorsing": 0,
    "numNonceRevelations": 0,
    "vdfRevelationsCount": 0,
    "numRevelationPenalties": 0,
    "numEndorsingRewards": 0,
    "numDelegations": 0,
    "numOriginations": 0,
    "numTransactions": 0,
    "numReveals": 0,
    "numRegisterConstants": 0,
    "numSetDepositsLimits": 0,
    "numMigrations": 0,
    "txRollupOriginationCount": 0,
    "txRollupSubmitBatchCount": 0,
    "txRollupCommitCount": 0,
    "txRollupReturnBondCount": 0,
    "txRollupFinalizeCommitmentCount": 0,
    "txRollupRemoveCommitmentCount": 0,
    "txRollupRejectionCount": 0,
    "txRollupDispatchTicketsCount": 0,
    "transferTicketCount": 0,
    "increasePaidStorageCount": 0,
    "updateConsensusKeyCount": 0,
    "drainDelegateCount": 0,
    "smartRollupAddMessagesCount": 0,
    "smartRollupCementCount": 0,
    "smartRollupExecuteCount": 0,
    "smartRollupOriginateCount": 0,
    "smartRollupPublishCount": 0,
    "smartRollupRecoverBondCount": 0,
    "smartRollupRefuteCount": 0,
    "refutationGamesCount": 0,
    "activeRefutationGamesCount": 0,
    "stakingOpsCount": 0,
    "autostakingOpsCount": 0,
    "firstActivity": 0,
    "firstActivityTime": "2024-01-15T09:30:00Z",
    "lastActivity": 0,
    "lastActivityTime": "2024-01-15T09:30:00Z",
    "software": {
      "version": "string",
      "date": "2024-01-15T09:30:00Z"
    },
    "frozenDeposit": 0,
    "frozenDeposits": 0,
    "frozenRewards": 0,
    "frozenFees": 0
  }
]

Get delegates count

GET

https://xtz-index.nownodes.io/v1/delegates/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a number of delegate accounts.

Parameters

activeBoolParameter | nullquery

Delegate status to filter by (true - only active, false - only deactivated, undefined - all delegates)

Response

200OK

Get delegates count

curl -X GET 'https://xtz-index.nownodes.io/v1/delegates/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/delegates/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/delegates/count')
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://xtz-index.nownodes.io/v1/delegates/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/delegates/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/delegates/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/delegates/count')
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

Get delegate by address

GET

https://xtz-index.nownodes.io/v1/delegates/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a delegate with the specified address.

Parameters

addressstringrequiredpath

Delegate address (starting with tz)

Response

200OK

Get delegate by address

curl -X GET 'https://xtz-index.nownodes.io/v1/delegates/{address}'

const response = await fetch('https://xtz-index.nownodes.io/v1/delegates/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/delegates/{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://xtz-index.nownodes.io/v1/delegates/{address}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/delegates/{address}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/delegates/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/delegates/{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

{
  "type": "string",
  "id": 0,
  "address": "string",
  "active": true,
  "alias": "string",
  "publicKey": "string",
  "revealed": true,
  "balance": 0,
  "rollupBonds": 0,
  "smartRollupBonds": 0,
  "stakedBalance": 0,
  "stakedPseudotokens": 0,
  "unstakedBalance": 0,
  "unstakedBaker": {
    "alias": "string",
    "address": "string"
  },
  "externalStakedBalance": 0,
  "externalUnstakedBalance": 0,
  "totalStakedBalance": 0,
  "issuedPseudotokens": 0,
  "stakersCount": 0,
  "lostBalance": 0,
  "frozenDepositLimit": 0,
  "limitOfStakingOverBaking": 0,
  "edgeOfBakingOverStaking": 0,
  "counter": 0,
  "activationLevel": 0,
  "activationTime": "2024-01-15T09:30:00Z",
  "deactivationLevel": 0,
  "deactivationTime": "2024-01-15T09:30:00Z",
  "stakingBalance": 0,
  "delegatedBalance": 0,
  "numContracts": 0,
  "rollupsCount": 0,
  "smartRollupsCount": 0,
  "activeTokensCount": 0,
  "tokenBalancesCount": 0,
  "tokenTransfersCount": 0,
  "activeTicketsCount": 0,
  "ticketBalancesCount": 0,
  "ticketTransfersCount": 0,
  "numDelegators": 0,
  "numBlocks": 0,
  "numEndorsements": 0,
  "numPreendorsements": 0,
  "numBallots": 0,
  "numProposals": 0,
  "numActivations": 0,
  "numDoubleBaking": 0,
  "numDoubleEndorsing": 0,
  "numDoublePreendorsing": 0,
  "numNonceRevelations": 0,
  "vdfRevelationsCount": 0,
  "numRevelationPenalties": 0,
  "numEndorsingRewards": 0,
  "numDelegations": 0,
  "numOriginations": 0,
  "numTransactions": 0,
  "numReveals": 0,
  "numRegisterConstants": 0,
  "numSetDepositsLimits": 0,
  "numMigrations": 0,
  "txRollupOriginationCount": 0,
  "txRollupSubmitBatchCount": 0,
  "txRollupCommitCount": 0,
  "txRollupReturnBondCount": 0,
  "txRollupFinalizeCommitmentCount": 0,
  "txRollupRemoveCommitmentCount": 0,
  "txRollupRejectionCount": 0,
  "txRollupDispatchTicketsCount": 0,
  "transferTicketCount": 0,
  "increasePaidStorageCount": 0,
  "updateConsensusKeyCount": 0,
  "drainDelegateCount": 0,
  "smartRollupAddMessagesCount": 0,
  "smartRollupCementCount": 0,
  "smartRollupExecuteCount": 0,
  "smartRollupOriginateCount": 0,
  "smartRollupPublishCount": 0,
  "smartRollupRecoverBondCount": 0,
  "smartRollupRefuteCount": 0,
  "refutationGamesCount": 0,
  "activeRefutationGamesCount": 0,
  "stakingOpsCount": 0,
  "autostakingOpsCount": 0,
  "firstActivity": 0,
  "firstActivityTime": "2024-01-15T09:30:00Z",
  "lastActivity": 0,
  "lastActivityTime": "2024-01-15T09:30:00Z",
  "software": {
    "version": "string",
    "date": "2024-01-15T09:30:00Z"
  },
  "frozenDeposit": 0,
  "frozenDeposits": 0,
  "frozenRewards": 0,
  "frozenFees": 0
}

Domains

Get domains count

GET

https://xtz-index.nownodes.io/v1/domains/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of domains.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

nameStringParameter | nullquery

Filter by the domain name.
Click on the parameter to expand more details.

ownerAddressNullParameter | nullquery

Filter by the domain owner.
Click on the parameter to expand more details.

addressAddressNullParameter | nullquery

Filter by the address the domain points to.
Click on the parameter to expand more details.

reverseBoolParameter | nullquery

Filter by the 'reverse' flag.
Click on the parameter to expand more details.

expirationDateTimeParameter | nullquery

Filter by the domain expiration.
Click on the parameter to expand more details.

dataJsonParameter | nullquery

Filter by the domain data.
Note, this parameter supports the following format: data{.path?}{.mode?}=..., so you can specify a path to a particular field to filter by (for example, ?data.foo=bar).
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block where the domain was first seen.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the domain was first seen.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block where the domain was last seen.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the domain was last seen.
Click on the parameter to expand more details.

Response

200OK

Get domains count

curl -X GET 'https://xtz-index.nownodes.io/v1/domains/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/domains/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/domains/count')
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://xtz-index.nownodes.io/v1/domains/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/domains/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/domains/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/domains/count')
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

Get domains

GET

https://xtz-index.nownodes.io/v1/domains

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of domains.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

nameStringParameter | nullquery

Filter by the domain name.
Click on the parameter to expand more details.

ownerAddressNullParameter | nullquery

Filter by the domain owner.
Click on the parameter to expand more details.

addressAddressNullParameter | nullquery

Filter by the address the domain points to.
Click on the parameter to expand more details.

reverseBoolParameter | nullquery

Filter by the 'reverse' flag.
Click on the parameter to expand more details.

expirationDateTimeParameter | nullquery

Filter by the domain expiration.
Click on the parameter to expand more details.

dataJsonParameter | nullquery

firstLevelInt32Parameter | nullquery

Filter by level of the block where the domain was first seen.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the domain was first seen.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block where the domain was last seen.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the domain was last seen.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get domains

curl -X GET 'https://xtz-index.nownodes.io/v1/domains'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/domains')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/domains')
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": 0,
    "level": 0,
    "name": "string",
    "owner": {
      "alias": "string",
      "address": "string"
    },
    "address": {
      "alias": "string",
      "address": "string"
    },
    "reverse": true,
    "expiration": "2024-01-15T09:30:00Z",
    "firstLevel": 0,
    "firstTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "lastTime": "2024-01-15T09:30:00Z"
  }
]

Get domain by name

GET

https://xtz-index.nownodes.io/v1/domains/{name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the domain with the specified name.

Parameters

namestringrequiredpath

Domain name

Response

200OK

Get domain by name

curl -X GET 'https://xtz-index.nownodes.io/v1/domains/{name}'

const response = await fetch('https://xtz-index.nownodes.io/v1/domains/{name}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/domains/{name}')
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://xtz-index.nownodes.io/v1/domains/{name}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/domains/{name}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/domains/{name}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/domains/{name}')
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": 0,
  "level": 0,
  "name": "string",
  "owner": {
    "alias": "string",
    "address": "string"
  },
  "address": {
    "alias": "string",
    "address": "string"
  },
  "reverse": true,
  "expiration": "2024-01-15T09:30:00Z",
  "firstLevel": 0,
  "firstTime": "2024-01-15T09:30:00Z",
  "lastLevel": 0,
  "lastTime": "2024-01-15T09:30:00Z"
}

Events

Get contract events count

GET

https://xtz-index.nownodes.io/v1/contracts/events/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of contract events.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by level of the block where the event was emitted.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the event was emitted.
Click on the parameter to expand more details.

contractAccountParameter | nullquery

Filter by contract address.
Click on the parameter to expand more details.

codeHashInt32Parameter | nullquery

Filter by hash of the code of the contract emitted the event.
Click on the parameter to expand more details.

tagStringParameter | nullquery

Filter by event tag.
Click on the parameter to expand more details.

payloadJsonParameter | nullquery

Filter by payload.
Note, this parameter supports the following format: payload{.path?}{.mode?}=..., so you can specify a path to a particular field to filter by (for example, ?payload.foo.bar.in=1,2,3).
Click on the parameter to expand more details.

transactionIdInt64Parameter | nullquery

Filter by id of the transaction, in which the event was emitted.
Click on the parameter to expand more details.

Response

200OK

Get contract events count

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/events/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/events/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/events/count')
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://xtz-index.nownodes.io/v1/contracts/events/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/events/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/events/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/events/count')
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

Get contract events

GET

https://xtz-index.nownodes.io/v1/contracts/events

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of contract events.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by level of the block where the event was emitted.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the event was emitted.
Click on the parameter to expand more details.

contractAccountParameter | nullquery

Filter by contract address.
Click on the parameter to expand more details.

codeHashInt32Parameter | nullquery

Filter by hash of the code of the contract emitted the event.
Click on the parameter to expand more details.

tagStringParameter | nullquery

Filter by event tag.
Click on the parameter to expand more details.

payloadJsonParameter | nullquery

transactionIdInt64Parameter | nullquery

Filter by id of the transaction, in which the event was emitted.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get contract events

curl -X GET 'https://xtz-index.nownodes.io/v1/contracts/events'

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/events', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/events')
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://xtz-index.nownodes.io/v1/contracts/events')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/contracts/events', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/contracts/events')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/contracts/events')
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": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "contract": {
      "alias": "string",
      "address": "string"
    },
    "codeHash": 0,
    "tag": "string",
    "transactionId": 0
  }
]

Head

Get indexer head

GET

https://xtz-index.nownodes.io/v1/head

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns indexer head and synchronization status.

Response

200OK

Get indexer head

curl -X GET 'https://xtz-index.nownodes.io/v1/head'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/head')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/head')
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

{
  "chain": "string",
  "chainId": "string",
  "cycle": 0,
  "level": 0,
  "hash": "string",
  "protocol": "string",
  "nextProtocol": "string",
  "timestamp": "2024-01-15T09:30:00Z",
  "votingEpoch": 0,
  "votingPeriod": 0,
  "knownLevel": 0,
  "lastSync": "2024-01-15T09:30:00Z",
  "synced": true,
  "quoteLevel": 0,
  "quoteBtc": 0,
  "quoteEur": 0,
  "quoteUsd": 0,
  "quoteCny": 0,
  "quoteJpy": 0,
  "quoteKrw": 0,
  "quoteEth": 0,
  "quoteGbp": 0
}

Helpers

Inject operation

POST

https://xtz-index.nownodes.io/v1/helpers/inject

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Injects signed operation to the blockchain and returns the operation hash.

Body

application/json

Forged operation bytes + signature in hex format.

string

Parameters

asyncbooleantruequery

If true, the function returns immediately. Otherwise, the operation will be validated before the result is returned.

Response

200OK

Inject operation

curl -X POST 'https://xtz-index.nownodes.io/v1/helpers/inject' \
  -H 'Content-Type: application/json' \
  -d '"string"'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/helpers/inject')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '"string"'

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

import requests

payload = "string"

response = requests.post('https://xtz-index.nownodes.io/v1/helpers/inject', json=payload)
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/helpers/inject";
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("string");
console.log(result);

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

const data = await response.json();

import requests

payload = "string"

response = requests.post('https://xtz-index.nownodes.io/v1/helpers/inject', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/helpers/inject')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '"string"'

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

Request Body

"string"

200

"string"

Run script view

POST

https://xtz-index.nownodes.io/v1/helpers/view/{contract}/{name}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Simulate a call to a michelson view

Body

application/json

Input to be passed to the contract view (in human-readable format, see "Json schema" on tzkt.io)

any

Parameters

contractstringrequiredpath

Contract address

namestringrequiredpath

View name

Response

200OK

Run script view

curl -X POST 'https://xtz-index.nownodes.io/v1/helpers/view/{contract}/{name}' \
  -H 'Content-Type: application/json'

const response = await fetch('https://xtz-index.nownodes.io/v1/helpers/view/{contract}/{name}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/helpers/view/{contract}/{name}')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'

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

import requests

response = requests.post('https://xtz-index.nownodes.io/v1/helpers/view/{contract}/{name}', headers={'Content-Type': 'application/json'})
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/helpers/view/{contract}/{name}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/helpers/view/{contract}/{name}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz-index.nownodes.io/v1/helpers/view/{contract}/{name}', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
});

const data = await response.json();

import requests

response = requests.post('https://xtz-index.nownodes.io/v1/helpers/view/{contract}/{name}', headers={'Content-Type': 'application/json'})
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/helpers/view/{contract}/{name}')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'

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

200

"<binary>"

Operations

Get operations by hash

GET

https://xtz-index.nownodes.io/v1/operations/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of operations with the specified hash.
NOTE: if you know in advance what operation type you want to get (e.g. transactions), prefer using /v1/operations/{type}/{hash} (e.g. /v1/operations/transactions/{hash}) instead, because it's much more efficient.

Parameters

hashstringrequiredpath

Operation hash

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get operations by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/{hash}')
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://xtz-index.nownodes.io/v1/operations/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/{hash}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/{hash}')
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

[
  {
    "type": "string"
  }
]

Get operations by hash and counter

GET

https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of operations with the specified hash and counter.
NOTE: if you know in advance what operation type you want to get (e.g. transactions), prefer using /v1/operations/{type}/{hash}/{counter} (e.g. /v1/operations/transactions/{hash}/{counter}) instead, because it's much more efficient.

Parameters

hashstringrequiredpath

Operation hash

counterinteger<int32>requiredpath

Operation counter

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get operations by hash and counter

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}')
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://xtz-index.nownodes.io/v1/operations/{hash}/{counter}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}";
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://xtz-index.nownodes.io/v1/operations/{hash}/{counter}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}')
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

[
  {
    "type": "string"
  }
]

Get operations by hash, counter and nonce

GET

https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}/{nonce}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an internal operations with the specified hash, counter and nonce.
NOTE: if you know in advance what operation type you want to get (e.g. transactions), prefer using /v1/operations/{type}/{hash}/{counter}/{nonce} (e.g. /v1/operations/transactions/{hash}/{counter}/{nonce}) instead, because it's much more efficient.

Parameters

hashstringrequiredpath

Operation hash

counterinteger<int32>requiredpath

Operation counter

nonceinteger<int32>requiredpath

Operation nonce (internal)

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get operations by hash, counter and nonce

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}/{nonce}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}/{nonce}')
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://xtz-index.nownodes.io/v1/operations/{hash}/{counter}/{nonce}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}/{nonce}";
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://xtz-index.nownodes.io/v1/operations/{hash}/{counter}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}/{nonce}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/{hash}/{counter}/{nonce}')
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

[
  {
    "type": "string"
  }
]

Get operation status

GET

https://xtz-index.nownodes.io/v1/operations/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.
NOTE: if you know in advance what operation type you want to check (e.g. transactions), prefer using /v1/operations/{type}/{hash}/status (e.g. /v1/operations/transactions/{hash}/status) instead, because it's much more efficient.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get operation status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/{hash}/status')
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

true

Get endorsements

GET

https://xtz-index.nownodes.io/v1/operations/endorsements

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of endorsement operations.

Parameters

delegateAccountParameter | nullquery

Filters endorsements by delegate. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters endorsements by level.

timestampDateTimeParameter | nullquery

Filters endorsements by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts endorsements by specified field. Supported fields: id (default), level.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get endorsements

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/endorsements'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsements', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsements')
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://xtz-index.nownodes.io/v1/operations/endorsements')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsements', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/endorsements')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsements')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "slots": 0,
    "deposit": 0,
    "rewards": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get endorsement by hash

GET

https://xtz-index.nownodes.io/v1/operations/endorsements/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an endorsement operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get endorsement by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/endorsements/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsements/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsements/{hash}')
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://xtz-index.nownodes.io/v1/operations/endorsements/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsements/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/endorsements/{hash}";
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://xtz-index.nownodes.io/v1/operations/endorsements/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/endorsements/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsements/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "slots": 0,
    "deposit": 0,
    "rewards": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get endorsements count

GET

https://xtz-index.nownodes.io/v1/operations/endorsements/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of endorsement operations.

Parameters

levelInt32Parameter | nullquery

Filters endorsements by level.

timestampDateTimeParameter | nullquery

Filters endorsements by timestamp.

Response

200OK

Get endorsements count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/endorsements/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsements/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsements/count')
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://xtz-index.nownodes.io/v1/operations/endorsements/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsements/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/endorsements/count";
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://xtz-index.nownodes.io/v1/operations/endorsements/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/endorsements/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsements/count')
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

Get preendorsements

GET

https://xtz-index.nownodes.io/v1/operations/preendorsements

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of preendorsement operations.

Parameters

delegateAccountParameter | nullquery

Filters by delegate. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get preendorsements

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/preendorsements'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/preendorsements', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/preendorsements')
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://xtz-index.nownodes.io/v1/operations/preendorsements')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/preendorsements', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/preendorsements')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/preendorsements')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "slots": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get preendorsement by hash

GET

https://xtz-index.nownodes.io/v1/operations/preendorsements/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an preendorsement operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get preendorsement by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/preendorsements/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/preendorsements/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/preendorsements/{hash}')
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://xtz-index.nownodes.io/v1/operations/preendorsements/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/preendorsements/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/preendorsements/{hash}";
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://xtz-index.nownodes.io/v1/operations/preendorsements/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/preendorsements/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/preendorsements/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "slots": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get preendorsements count

GET

https://xtz-index.nownodes.io/v1/operations/preendorsements/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of preendorsement operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get preendorsements count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/preendorsements/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/preendorsements/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/preendorsements/count')
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://xtz-index.nownodes.io/v1/operations/preendorsements/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/preendorsements/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/preendorsements/count";
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://xtz-index.nownodes.io/v1/operations/preendorsements/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/preendorsements/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/preendorsements/count')
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

Get ballots

GET

https://xtz-index.nownodes.io/v1/operations/ballots

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of ballot operations.

Parameters

delegateAccountParameter | nullquery

Filters ballots by delegate. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters ballots by level.

timestampDateTimeParameter | nullquery

Filters ballots by timestamp.

epochInt32Parameter | nullquery

Filters ballots by voting epoch.

periodInt32Parameter | nullquery

Filters ballots by voting period.

proposalProtocolParameter | nullquery

Filters ballots by proposal hash.

voteVoteParameter | nullquery

Filters ballots by vote (yay, nay, pass).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts ballots by specified field. Supported fields: id (default), level.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get ballots

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/ballots'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/ballots', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/ballots')
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://xtz-index.nownodes.io/v1/operations/ballots')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/ballots', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/ballots')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/ballots')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "period": {
      "index": 0,
      "epoch": 0,
      "kind": "string",
      "firstLevel": 0,
      "lastLevel": 0
    },
    "proposal": {
      "alias": "string",
      "hash": "string"
    },
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "votingPower": 0,
    "vote": "string",
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "rolls": 0
  }
]

Get ballot by hash

GET

https://xtz-index.nownodes.io/v1/operations/ballots/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a ballot operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get ballot by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/ballots/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/ballots/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/ballots/{hash}')
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://xtz-index.nownodes.io/v1/operations/ballots/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/ballots/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/ballots/{hash}";
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://xtz-index.nownodes.io/v1/operations/ballots/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/ballots/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/ballots/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "period": {
      "index": 0,
      "epoch": 0,
      "kind": "string",
      "firstLevel": 0,
      "lastLevel": 0
    },
    "proposal": {
      "alias": "string",
      "hash": "string"
    },
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "votingPower": 0,
    "vote": "string",
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "rolls": 0
  }
]

Get ballots count

GET

https://xtz-index.nownodes.io/v1/operations/ballots/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of ballot operations.

Parameters

levelInt32Parameter | nullquery

Filters ballot operations by level.

timestampDateTimeParameter | nullquery

Filters ballot operations by timestamp.

Response

200OK

Get ballots count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/ballots/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/ballots/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/ballots/count')
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://xtz-index.nownodes.io/v1/operations/ballots/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/ballots/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/ballots/count";
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://xtz-index.nownodes.io/v1/operations/ballots/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/ballots/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/ballots/count')
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

Get proposals

GET

https://xtz-index.nownodes.io/v1/operations/proposals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of proposal operations.

Parameters

delegateAccountParameter | nullquery

Filters proposal operations by delegate. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters proposal operations by level.

timestampDateTimeParameter | nullquery

Filters proposal operations by timestamp.

epochInt32Parameter | nullquery

Filters proposal operations by voting epoch.

periodInt32Parameter | nullquery

Filters proposal operations by voting period.

proposalProtocolParameter | nullquery

Filters proposal operations by proposal hash.

duplicatedBoolParameter | nullquery

Specify whether to include or exclude duplicates, which didn't actually upvote a proposal.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts proposal operations by specified field. Supported fields: id (default), level.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get proposals

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/proposals'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/proposals', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/proposals')
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://xtz-index.nownodes.io/v1/operations/proposals')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/proposals', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/proposals')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/proposals')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "period": {
      "index": 0,
      "epoch": 0,
      "kind": "string",
      "firstLevel": 0,
      "lastLevel": 0
    },
    "proposal": {
      "alias": "string",
      "hash": "string"
    },
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "votingPower": 0,
    "duplicated": true,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "rolls": 0
  }
]

Get proposal by hash

GET

https://xtz-index.nownodes.io/v1/operations/proposals/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a proposal operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get proposal by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/proposals/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/proposals/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/proposals/{hash}')
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://xtz-index.nownodes.io/v1/operations/proposals/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/proposals/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/proposals/{hash}";
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://xtz-index.nownodes.io/v1/operations/proposals/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/proposals/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/proposals/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "period": {
      "index": 0,
      "epoch": 0,
      "kind": "string",
      "firstLevel": 0,
      "lastLevel": 0
    },
    "proposal": {
      "alias": "string",
      "hash": "string"
    },
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "votingPower": 0,
    "duplicated": true,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "rolls": 0
  }
]

Get proposals count

GET

https://xtz-index.nownodes.io/v1/operations/proposals/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of proposal operations.

Parameters

levelInt32Parameter | nullquery

Filters proposal operations by level.

timestampDateTimeParameter | nullquery

Filters proposal operations by timestamp.

Response

200OK

Get proposals count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/proposals/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/proposals/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/proposals/count')
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://xtz-index.nownodes.io/v1/operations/proposals/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/proposals/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/proposals/count";
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://xtz-index.nownodes.io/v1/operations/proposals/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/proposals/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/proposals/count')
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

Get activations

GET

https://xtz-index.nownodes.io/v1/operations/activations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of activation operations.

Parameters

accountAccountParameter | nullquery

Filters activations by account. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters activations by level.

timestampDateTimeParameter | nullquery

Filters activations by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts activations by specified field. Supported fields: id (default), level, balance.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get activations

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/activations'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/activations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/activations')
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://xtz-index.nownodes.io/v1/operations/activations')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/activations', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/activations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/activations')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "account": {
      "alias": "string",
      "address": "string"
    },
    "balance": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get activation by hash

GET

https://xtz-index.nownodes.io/v1/operations/activations/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an activation operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get activation by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/activations/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/activations/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/activations/{hash}')
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://xtz-index.nownodes.io/v1/operations/activations/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/activations/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/activations/{hash}";
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://xtz-index.nownodes.io/v1/operations/activations/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/activations/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/activations/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "account": {
      "alias": "string",
      "address": "string"
    },
    "balance": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get activations count

GET

https://xtz-index.nownodes.io/v1/operations/activations/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of activation operations.

Parameters

levelInt32Parameter | nullquery

Filters activations by level.

timestampDateTimeParameter | nullquery

Filters activations by timestamp.

Response

200OK

Get activations count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/activations/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/activations/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/activations/count')
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://xtz-index.nownodes.io/v1/operations/activations/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/activations/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/activations/count";
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://xtz-index.nownodes.io/v1/operations/activations/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/activations/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/activations/count')
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

Get double baking

GET

https://xtz-index.nownodes.io/v1/operations/double_baking

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of double baking operations.

Parameters

anyofAnyOfParameter | nullquery

Filters double baking operations by any of the specified fields. Example: anyof.accuser.offender=tz1... will return operations where accuser OR offender is equal to the specified value. This parameter is useful when you need to retrieve all operations associated with a specified account.

accuserAccountParameter | nullquery

Filters double baking operations by accuser. Allowed fields for .eqx mode: offender.

offenderAccountParameter | nullquery

Filters double baking operations by offender. Allowed fields for .eqx mode: accuser.

levelInt32Parameter | nullquery

Filters double baking operations by level.

timestampDateTimeParameter | nullquery

Filters double baking operations by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts double baking operations by specified field. Supported fields: id (default), level, accusedLevel, accuserRewards, offenderLostDeposits, offenderLostRewards, offenderLostFees.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get double baking

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/double_baking'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_baking', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_baking')
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://xtz-index.nownodes.io/v1/operations/double_baking')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_baking', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/double_baking')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_baking')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "accusedLevel": 0,
    "slashedLevel": 0,
    "accuser": {
      "alias": "string",
      "address": "string"
    },
    "reward": 0,
    "offender": {
      "alias": "string",
      "address": "string"
    },
    "lostStaked": 0,
    "lostUnstaked": 0,
    "lostExternalStaked": 0,
    "lostExternalUnstaked": 0,
    "roundingLoss": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "offenderLoss": 0,
    "accuserReward": 0,
    "accuserRewards": 0,
    "offenderLostDeposits": 0,
    "offenderLostRewards": 0,
    "offenderLostFees": 0
  }
]

Get double baking by hash

GET

https://xtz-index.nownodes.io/v1/operations/double_baking/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a double baking operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get double baking by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/double_baking/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_baking/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_baking/{hash}')
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://xtz-index.nownodes.io/v1/operations/double_baking/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_baking/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/double_baking/{hash}";
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://xtz-index.nownodes.io/v1/operations/double_baking/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/double_baking/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_baking/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "accusedLevel": 0,
    "slashedLevel": 0,
    "accuser": {
      "alias": "string",
      "address": "string"
    },
    "reward": 0,
    "offender": {
      "alias": "string",
      "address": "string"
    },
    "lostStaked": 0,
    "lostUnstaked": 0,
    "lostExternalStaked": 0,
    "lostExternalUnstaked": 0,
    "roundingLoss": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "offenderLoss": 0,
    "accuserReward": 0,
    "accuserRewards": 0,
    "offenderLostDeposits": 0,
    "offenderLostRewards": 0,
    "offenderLostFees": 0
  }
]

Get double baking count

GET

https://xtz-index.nownodes.io/v1/operations/double_baking/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of double baking operations.

Parameters

levelInt32Parameter | nullquery

Filters double baking operations by level.

timestampDateTimeParameter | nullquery

Filters double baking operations by timestamp.

Response

200OK

Get double baking count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/double_baking/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_baking/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_baking/count')
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://xtz-index.nownodes.io/v1/operations/double_baking/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_baking/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/double_baking/count";
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://xtz-index.nownodes.io/v1/operations/double_baking/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/double_baking/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_baking/count')
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

Get double endorsing

GET

https://xtz-index.nownodes.io/v1/operations/double_endorsing

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of double endorsing operations.

Parameters

anyofAnyOfParameter | nullquery

Filters double endorsing operations by any of the specified fields. Example: anyof.accuser.offender=tz1... will return operations where accuser OR offender is equal to the specified value. This parameter is useful when you need to retrieve all operations associated with a specified account.

accuserAccountParameter | nullquery

Filters double endorsing operations by accuser. Allowed fields for .eqx mode: offender.

offenderAccountParameter | nullquery

Filters double endorsing operations by offender. Allowed fields for .eqx mode: accuser.

levelInt32Parameter | nullquery

Filters double endorsing operations by level.

timestampDateTimeParameter | nullquery

Filters double endorsing operations by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts double endorsing operations by specified field. Supported fields: id (default), level, accusedLevel, accuserRewards, offenderLostDeposits, offenderLostRewards, offenderLostFees.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get double endorsing

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/double_endorsing'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_endorsing', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_endorsing')
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://xtz-index.nownodes.io/v1/operations/double_endorsing')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_endorsing', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/double_endorsing')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_endorsing')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "accusedLevel": 0,
    "slashedLevel": 0,
    "accuser": {
      "alias": "string",
      "address": "string"
    },
    "reward": 0,
    "offender": {
      "alias": "string",
      "address": "string"
    },
    "lostStaked": 0,
    "lostUnstaked": 0,
    "lostExternalStaked": 0,
    "lostExternalUnstaked": 0,
    "roundingLoss": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "offenderLoss": 0,
    "accuserReward": 0,
    "accuserRewards": 0,
    "offenderLostDeposits": 0,
    "offenderLostRewards": 0,
    "offenderLostFees": 0
  }
]

Get double endorsing by hash

GET

https://xtz-index.nownodes.io/v1/operations/double_endorsing/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a double endorsing operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get double endorsing by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/double_endorsing/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_endorsing/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_endorsing/{hash}')
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://xtz-index.nownodes.io/v1/operations/double_endorsing/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_endorsing/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/double_endorsing/{hash}";
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://xtz-index.nownodes.io/v1/operations/double_endorsing/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/double_endorsing/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_endorsing/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "accusedLevel": 0,
    "slashedLevel": 0,
    "accuser": {
      "alias": "string",
      "address": "string"
    },
    "reward": 0,
    "offender": {
      "alias": "string",
      "address": "string"
    },
    "lostStaked": 0,
    "lostUnstaked": 0,
    "lostExternalStaked": 0,
    "lostExternalUnstaked": 0,
    "roundingLoss": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "offenderLoss": 0,
    "accuserReward": 0,
    "accuserRewards": 0,
    "offenderLostDeposits": 0,
    "offenderLostRewards": 0,
    "offenderLostFees": 0
  }
]

Get double endorsing count

GET

https://xtz-index.nownodes.io/v1/operations/double_endorsing/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of double endorsing operations.

Parameters

levelInt32Parameter | nullquery

Filters double endorsing operations by level.

timestampDateTimeParameter | nullquery

Filters double endorsing operations by timestamp.

Response

200OK

Get double endorsing count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/double_endorsing/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_endorsing/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_endorsing/count')
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://xtz-index.nownodes.io/v1/operations/double_endorsing/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_endorsing/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/double_endorsing/count";
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://xtz-index.nownodes.io/v1/operations/double_endorsing/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/double_endorsing/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_endorsing/count')
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

Get double preendorsing

GET

https://xtz-index.nownodes.io/v1/operations/double_preendorsing

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of double preendorsing operations.

Parameters

anyofAnyOfParameter | nullquery

Filters by any of the specified fields. Example: anyof.accuser.offender=tz1... will return operations where accuser OR offender is equal to the specified value. This parameter is useful when you need to retrieve all operations associated with a specified account.

accuserAccountParameter | nullquery

Filters by accuser. Allowed fields for .eqx mode: offender.

offenderAccountParameter | nullquery

Filters by offender. Allowed fields for .eqx mode: accuser.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level, accusedLevel, accuserRewards, offenderLostDeposits, offenderLostRewards, offenderLostFees.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get double preendorsing

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/double_preendorsing'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_preendorsing', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_preendorsing')
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://xtz-index.nownodes.io/v1/operations/double_preendorsing')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_preendorsing', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/double_preendorsing')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_preendorsing')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "accusedLevel": 0,
    "slashedLevel": 0,
    "accuser": {
      "alias": "string",
      "address": "string"
    },
    "reward": 0,
    "offender": {
      "alias": "string",
      "address": "string"
    },
    "lostStaked": 0,
    "lostUnstaked": 0,
    "lostExternalStaked": 0,
    "lostExternalUnstaked": 0,
    "roundingLoss": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "offenderLoss": 0,
    "accuserReward": 0
  }
]

Get double preendorsing by hash

GET

https://xtz-index.nownodes.io/v1/operations/double_preendorsing/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a double preendorsing operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get double preendorsing by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/double_preendorsing/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_preendorsing/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_preendorsing/{hash}')
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://xtz-index.nownodes.io/v1/operations/double_preendorsing/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_preendorsing/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/double_preendorsing/{hash}";
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://xtz-index.nownodes.io/v1/operations/double_preendorsing/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/double_preendorsing/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_preendorsing/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "accusedLevel": 0,
    "slashedLevel": 0,
    "accuser": {
      "alias": "string",
      "address": "string"
    },
    "reward": 0,
    "offender": {
      "alias": "string",
      "address": "string"
    },
    "lostStaked": 0,
    "lostUnstaked": 0,
    "lostExternalStaked": 0,
    "lostExternalUnstaked": 0,
    "roundingLoss": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "offenderLoss": 0,
    "accuserReward": 0
  }
]

Get double preendorsing count

GET

https://xtz-index.nownodes.io/v1/operations/double_preendorsing/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of double preendorsing operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get double preendorsing count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/double_preendorsing/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_preendorsing/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_preendorsing/count')
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://xtz-index.nownodes.io/v1/operations/double_preendorsing/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/double_preendorsing/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/double_preendorsing/count";
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://xtz-index.nownodes.io/v1/operations/double_preendorsing/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/double_preendorsing/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/double_preendorsing/count')
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

Get nonce revelations

GET

https://xtz-index.nownodes.io/v1/operations/nonce_revelations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of seed nonce revelation operations.

Parameters

anyofAnyOfParameter | nullquery

Filters nonce revelation operations by any of the specified fields. Example: anyof.baker.sender=tz1... will return operations where baker OR sender is equal to the specified value. This parameter is useful when you need to retrieve all operations associated with a specified account.

bakerAccountParameter | nullquery

Filters nonce revelation operations by baker. Allowed fields for .eqx mode: sender.

senderAccountParameter | nullquery

Filters nonce revelation operations by sender. Allowed fields for .eqx mode: baker.

levelInt32Parameter | nullquery

Filters nonce revelation operations by level.

revealedCycleInt32Parameter | nullquery

Filters by cycle for which the nonce was revealed.

timestampDateTimeParameter | nullquery

Filters nonce revelation operations by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts nonce revelation operations by specified field. Supported fields: id (default), level, revealedLevel.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get nonce revelations

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/nonce_revelations'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/nonce_revelations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/nonce_revelations')
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://xtz-index.nownodes.io/v1/operations/nonce_revelations')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/nonce_revelations', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/nonce_revelations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/nonce_revelations')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "revealedLevel": 0,
    "revealedCycle": 0,
    "nonce": "string",
    "rewardLiquid": 0,
    "rewardStakedOwn": 0,
    "rewardStakedShared": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "reward": 0,
    "bakerRewards": 0
  }
]

Get nonce revelation by hash

GET

https://xtz-index.nownodes.io/v1/operations/nonce_revelations/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a seed nonce revelation operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get nonce revelation by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/nonce_revelations/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/nonce_revelations/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/nonce_revelations/{hash}')
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://xtz-index.nownodes.io/v1/operations/nonce_revelations/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/nonce_revelations/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/nonce_revelations/{hash}";
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://xtz-index.nownodes.io/v1/operations/nonce_revelations/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/nonce_revelations/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/nonce_revelations/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "revealedLevel": 0,
    "revealedCycle": 0,
    "nonce": "string",
    "rewardLiquid": 0,
    "rewardStakedOwn": 0,
    "rewardStakedShared": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "reward": 0,
    "bakerRewards": 0
  }
]

Get nonce revelations count

GET

https://xtz-index.nownodes.io/v1/operations/nonce_revelations/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of seed nonce revelation operations.

Parameters

levelInt32Parameter | nullquery

Filters seed nonce revelation operations by level.

timestampDateTimeParameter | nullquery

Filters seed nonce revelation operations by timestamp.

Response

200OK

Get nonce revelations count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/nonce_revelations/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/nonce_revelations/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/nonce_revelations/count')
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://xtz-index.nownodes.io/v1/operations/nonce_revelations/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/nonce_revelations/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/nonce_revelations/count";
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://xtz-index.nownodes.io/v1/operations/nonce_revelations/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/nonce_revelations/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/nonce_revelations/count')
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

Get vdf revelations

GET

https://xtz-index.nownodes.io/v1/operations/vdf_revelations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of vdf revelation operations.

Parameters

bakerAccountParameter | nullquery

Filters by baker. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

cycleInt32Parameter | nullquery

Filters by cycle in which the operation was included.

timestampDateTimeParameter | nullquery

Filters by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get vdf revelations

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/vdf_revelations'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/vdf_revelations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/vdf_revelations')
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://xtz-index.nownodes.io/v1/operations/vdf_revelations')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/vdf_revelations', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/vdf_revelations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/vdf_revelations')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "cycle": 0,
    "solution": "string",
    "proof": "string",
    "rewardLiquid": 0,
    "rewardStakedOwn": 0,
    "rewardStakedShared": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "reward": 0
  }
]

Get vdf revelation by hash

GET

https://xtz-index.nownodes.io/v1/operations/vdf_revelations/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a vdf revelation operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get vdf revelation by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/vdf_revelations/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/vdf_revelations/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/vdf_revelations/{hash}')
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://xtz-index.nownodes.io/v1/operations/vdf_revelations/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/vdf_revelations/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/vdf_revelations/{hash}";
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://xtz-index.nownodes.io/v1/operations/vdf_revelations/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/vdf_revelations/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/vdf_revelations/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "cycle": 0,
    "solution": "string",
    "proof": "string",
    "rewardLiquid": 0,
    "rewardStakedOwn": 0,
    "rewardStakedShared": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "reward": 0
  }
]

Get vdf revelations count

GET

https://xtz-index.nownodes.io/v1/operations/vdf_revelations/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of vdf revelation operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get vdf revelations count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/vdf_revelations/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/vdf_revelations/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/vdf_revelations/count')
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://xtz-index.nownodes.io/v1/operations/vdf_revelations/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/vdf_revelations/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/vdf_revelations/count";
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://xtz-index.nownodes.io/v1/operations/vdf_revelations/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/vdf_revelations/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/vdf_revelations/count')
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

Get drain delegate

GET

https://xtz-index.nownodes.io/v1/operations/drain_delegate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of drain delegate operations.

Parameters

anyofAnyOfParameter | nullquery

Filters by any of the specified fields. Example: anyof.delegate.target=tz1... will return operations where delegate OR target is equal to the specified value. This parameter is useful when you need to retrieve all operations associated with a specified account.

delegateAccountParameter | nullquery

Filters by drained baker. Allowed fields for .eqx mode: none.

targetAccountParameter | nullquery

Filters by target. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get drain delegate

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/drain_delegate'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/drain_delegate', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/drain_delegate')
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://xtz-index.nownodes.io/v1/operations/drain_delegate')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/drain_delegate', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/drain_delegate')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/drain_delegate')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "target": {
      "alias": "string",
      "address": "string"
    },
    "amount": 0,
    "fee": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get drain delegate by hash

GET

https://xtz-index.nownodes.io/v1/operations/drain_delegate/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a drain delegate operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get drain delegate by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/drain_delegate/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/drain_delegate/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/drain_delegate/{hash}')
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://xtz-index.nownodes.io/v1/operations/drain_delegate/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/drain_delegate/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/drain_delegate/{hash}";
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://xtz-index.nownodes.io/v1/operations/drain_delegate/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/drain_delegate/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/drain_delegate/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "target": {
      "alias": "string",
      "address": "string"
    },
    "amount": 0,
    "fee": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get drain delegate count

GET

https://xtz-index.nownodes.io/v1/operations/drain_delegate/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of drain delegate operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get drain delegate count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/drain_delegate/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/drain_delegate/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/drain_delegate/count')
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://xtz-index.nownodes.io/v1/operations/drain_delegate/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/drain_delegate/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/drain_delegate/count";
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://xtz-index.nownodes.io/v1/operations/drain_delegate/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/drain_delegate/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/drain_delegate/count')
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

Get delegations

GET

https://xtz-index.nownodes.io/v1/operations/delegations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of delegation operations.

Parameters

anyofAnyOfParameter | nullquery

Filters delegations by any of the specified fields. Example: anyof.prevDelegate.newDelegate=tz1... will return operations where prevDelegate OR newDelegate is equal to the specified value. This parameter is useful when you need to retrieve all delegations associated with a specified account.

initiatorAccountParameter | nullquery

Filters delegations by initiator. Allowed fields for .eqx mode: prevDelegate, newDelegate.

senderAccountParameter | nullquery

Filters delegations by sender. Allowed fields for .eqx mode: prevDelegate, newDelegate.

prevDelegateAccountParameter | nullquery

Filters delegations by prev delegate. Allowed fields for .eqx mode: initiator, sender, newDelegate.

newDelegateAccountParameter | nullquery

Filters delegations by new delegate. Allowed fields for .eqx mode: initiator, sender, prevDelegate.

levelInt32Parameter | nullquery

Filters delegations by level.

timestampDateTimeParameter | nullquery

Filters delegations by timestamp.

senderCodeHashInt32Parameter | nullquery

Filters by senderCodeHash.

statusOperationStatusParameter | nullquery

Filters delegations by operation status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts delegations by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get delegations

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/delegations'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/delegations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/delegations')
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://xtz-index.nownodes.io/v1/operations/delegations')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/delegations', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/delegations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/delegations')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "counter": 0,
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "senderCodeHash": 0,
    "nonce": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "amount": 0,
    "unstakedPseudotokens": 0,
    "unstakedBalance": 0,
    "unstakedRewards": 0,
    "prevDelegate": {
      "alias": "string",
      "address": "string"
    },
    "newDelegate": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get delegation by hash

GET

https://xtz-index.nownodes.io/v1/operations/delegations/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a delegation operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get delegation by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/delegations/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/delegations/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/delegations/{hash}')
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://xtz-index.nownodes.io/v1/operations/delegations/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/delegations/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/delegations/{hash}";
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://xtz-index.nownodes.io/v1/operations/delegations/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/delegations/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/delegations/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "counter": 0,
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "senderCodeHash": 0,
    "nonce": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "amount": 0,
    "unstakedPseudotokens": 0,
    "unstakedBalance": 0,
    "unstakedRewards": 0,
    "prevDelegate": {
      "alias": "string",
      "address": "string"
    },
    "newDelegate": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get delegation status

GET

https://xtz-index.nownodes.io/v1/operations/delegations/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get delegation status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/delegations/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/delegations/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/delegations/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/delegations/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/delegations/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/delegations/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/delegations/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/delegations/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/delegations/{hash}/status')
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

true

Get delegations count

GET

https://xtz-index.nownodes.io/v1/operations/delegations/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of delegation operations.

Parameters

levelInt32Parameter | nullquery

Filters delegations by level.

timestampDateTimeParameter | nullquery

Filters delegations by timestamp.

Response

200OK

Get delegations count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/delegations/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/delegations/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/delegations/count')
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://xtz-index.nownodes.io/v1/operations/delegations/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/delegations/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/delegations/count";
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://xtz-index.nownodes.io/v1/operations/delegations/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/delegations/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/delegations/count')
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

Get originations

GET

https://xtz-index.nownodes.io/v1/operations/originations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of origination operations.

Parameters

anyofAnyOfParameter | nullquery

Filters originations by any of the specified fields. Example: anyof.sender.initiator=tz1... will return operations where sender OR initiator is equal to the specified value. This parameter is useful when you need to retrieve all originations associated with a specified account.

initiatorAccountParameter | nullquery

Filters origination operations by initiator. Allowed fields for .eqx mode: contractManager, contractDelegate.

senderAccountParameter | nullquery

Filters origination operations by sender. Allowed fields for .eqx mode: contractManager, contractDelegate.

contractManagerAccountParameter | nullquery

Filters origination operations by manager. Allowed fields for .eqx mode: initiator, sender, contractDelegate.

contractDelegateAccountParameter | nullquery

Filters origination operations by delegate. Allowed fields for .eqx mode: initiator, sender, contractManager.

originatedContractAccountParameter | nullquery

Filters origination operations by originated contract. Allowed fields for .eqx mode: none.

idInt64Parameter | nullquery

Filters origination operations by internal TzKT id

typeHashInt32Parameter | nullquery

Filters origination operations by 32-bit hash of originated contract parameter and storage types (helpful for searching originations of similar contracts)

codeHashInt32Parameter | nullquery

Filters origination operations by 32-bit hash of originated contract code (helpful for searching originations of same contracts)

levelInt32Parameter | nullquery

Filters origination operations by level.

timestampTimestampParameter | nullquery

Filters origination operations by timestamp.

senderCodeHashInt32Parameter | nullquery

Filters by senderCodeHash.

anyCodeHashInt32Parameter | nullquery

Filters by either senderCodeHash or codeHash.

statusOperationStatusParameter | nullquery

Filters origination operations by operation status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts originations by specified field. Supported fields: id (default), level, gasUsed, storageUsed, bakerFee, storageFee, allocationFee, contractBalance.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get originations

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/originations'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/originations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/originations')
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://xtz-index.nownodes.io/v1/operations/originations')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/originations', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/originations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/originations')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "counter": 0,
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "senderCodeHash": 0,
    "nonce": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "allocationFee": 0,
    "contractBalance": 0,
    "contractManager": {
      "alias": "string",
      "address": "string"
    },
    "contractDelegate": {
      "alias": "string",
      "address": "string"
    },
    "diffs": [
      {
        "bigmap": 0,
        "path": "string",
        "action": "string",
        "content": {
          "hash": "string"
        }
      }
    ],
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "originatedContract": {
      "kind": "string",
      "alias": "string",
      "address": "string",
      "typeHash": 0,
      "codeHash": 0,
      "tzips": [
        "string"
      ]
    },
    "tokenTransfersCount": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get origination by hash

GET

https://xtz-index.nownodes.io/v1/operations/originations/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns origination operations with specified hash.

Parameters

hashstringrequiredpath

Operation hash

michelineMichelineFormatJsonJsonStringRawRawStringquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get origination by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/originations/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/originations/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/originations/{hash}')
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://xtz-index.nownodes.io/v1/operations/originations/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/originations/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/originations/{hash}";
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://xtz-index.nownodes.io/v1/operations/originations/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/originations/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/originations/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "counter": 0,
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "senderCodeHash": 0,
    "nonce": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "allocationFee": 0,
    "contractBalance": 0,
    "contractManager": {
      "alias": "string",
      "address": "string"
    },
    "contractDelegate": {
      "alias": "string",
      "address": "string"
    },
    "diffs": [
      {
        "bigmap": 0,
        "path": "string",
        "action": "string",
        "content": {
          "hash": "string"
        }
      }
    ],
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "originatedContract": {
      "kind": "string",
      "alias": "string",
      "address": "string",
      "typeHash": 0,
      "codeHash": 0,
      "tzips": [
        "string"
      ]
    },
    "tokenTransfersCount": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get origination status

GET

https://xtz-index.nownodes.io/v1/operations/originations/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get origination status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/originations/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/originations/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/originations/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/originations/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/originations/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/originations/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/originations/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/originations/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/originations/{hash}/status')
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

true

Get originations count

GET

https://xtz-index.nownodes.io/v1/operations/originations/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of origination operations.

Parameters

levelInt32Parameter | nullquery

Filters originations by level.

timestampTimestampParameter | nullquery

Filters originations by timestamp.

Response

200OK

Get originations count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/originations/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/originations/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/originations/count')
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://xtz-index.nownodes.io/v1/operations/originations/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/originations/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/originations/count";
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://xtz-index.nownodes.io/v1/operations/originations/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/originations/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/originations/count')
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

Get transactions

GET

https://xtz-index.nownodes.io/v1/operations/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of transaction operations.

Parameters

anyofAnyOfParameter | nullquery

Filters transactions by any of the specified fields. Example: anyof.sender.target=tz1... will return operations where sender OR target is equal to the specified value. This parameter is useful when you need to retrieve all transactions associated with a specified account.

initiatorAccountParameter | nullquery

Filters transactions by initiator. Allowed fields for .eqx mode: target.

senderAccountParameter | nullquery

Filters transactions by sender. Allowed fields for .eqx mode: target.

targetAccountParameter | nullquery

Filters transactions by target. Allowed fields for .eqx mode: sender, initiator.

amountInt64Parameter | nullquery

Filters transactions by amount (micro tez).

idInt64Parameter | nullquery

Filters transactions by id.

levelInt32Parameter | nullquery

Filters transactions by level.

timestampTimestampParameter | nullquery

Filters transactions by timestamp.

senderCodeHashInt32Parameter | nullquery

Filters by senderCodeHash.

targetCodeHashInt32Parameter | nullquery

Filters by targetCodeHash.

codeHashInt32Parameter | nullquery

Filters by either senderCodeHash or targetCodeHash.

entrypointStringParameter | nullquery

Filters transactions by entrypoint called on the target contract.

parameterJsonParameter | nullquery

Filters transactions by parameter value. Note, this query parameter supports the following format: ?parameter{.path?}{.mode?}=..., so you can specify a path to a particular field to filter by, for example: ?parameter.token_id=... or ?parameter.sigs.0.ne=.... Also, note that .value part must be omitted in the path, so, for example, filtering by parameter.value.foo must be specified as ?parameter.foo=....

hasInternalsBoolParameter | nullquery

Filters transactions by presence of internal operations.

statusOperationStatusParameter | nullquery

Filters transactions by operation status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts transactions by specified field. Supported fields: id (default), level, gasUsed, storageUsed, bakerFee, storageFee, allocationFee, amount.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get transactions

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/transactions'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/transactions";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

200

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "counter": 0,
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "senderCodeHash": 0,
    "nonce": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "allocationFee": 0,
    "target": {
      "alias": "string",
      "address": "string"
    },
    "targetCodeHash": 0,
    "amount": 0,
    "parameter": {
      "entrypoint": "string"
    },
    "diffs": [
      {
        "bigmap": 0,
        "path": "string",
        "action": "string",
        "content": {
          "hash": "string"
        }
      }
    ],
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "hasInternals": true,
    "tokenTransfersCount": 0,
    "ticketTransfersCount": 0,
    "eventsCount": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get transaction by hash

GET

https://xtz-index.nownodes.io/v1/operations/transactions/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns transaction operations with specified hash.

Parameters

hashstringrequiredpath

Operation hash

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get transaction by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/transactions/{hash}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}')
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://xtz-index.nownodes.io/v1/operations/transactions/{hash}')
data = response.json()

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "counter": 0,
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "senderCodeHash": 0,
    "nonce": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "allocationFee": 0,
    "target": {
      "alias": "string",
      "address": "string"
    },
    "targetCodeHash": 0,
    "amount": 0,
    "parameter": {
      "entrypoint": "string"
    },
    "diffs": [
      {
        "bigmap": 0,
        "path": "string",
        "action": "string",
        "content": {
          "hash": "string"
        }
      }
    ],
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "hasInternals": true,
    "tokenTransfersCount": 0,
    "ticketTransfersCount": 0,
    "eventsCount": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get transaction by hash and counter

GET

https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns transaction operations with specified hash and counter.

Parameters

hashstringrequiredpath

Operation hash

counterinteger<int32>requiredpath

Operation counter

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get transaction by hash and counter

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}')
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://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "counter": 0,
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "senderCodeHash": 0,
    "nonce": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "allocationFee": 0,
    "target": {
      "alias": "string",
      "address": "string"
    },
    "targetCodeHash": 0,
    "amount": 0,
    "parameter": {
      "entrypoint": "string"
    },
    "diffs": [
      {
        "bigmap": 0,
        "path": "string",
        "action": "string",
        "content": {
          "hash": "string"
        }
      }
    ],
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "hasInternals": true,
    "tokenTransfersCount": 0,
    "ticketTransfersCount": 0,
    "eventsCount": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get transaction by hash, counter and nonce

GET

https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}/{nonce}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an internal transaction operation with specified hash, counter and nonce.

Parameters

hashstringrequiredpath

Operation hash

counterinteger<int32>requiredpath

Operation counter

nonceinteger<int32>requiredpath

Operation nonce (internal)

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get transaction by hash, counter and nonce

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}/{nonce}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}/{nonce}')
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://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}/{nonce}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}/{nonce}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}/{nonce}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/{counter}/{nonce}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "counter": 0,
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "senderCodeHash": 0,
    "nonce": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "allocationFee": 0,
    "target": {
      "alias": "string",
      "address": "string"
    },
    "targetCodeHash": 0,
    "amount": 0,
    "parameter": {
      "entrypoint": "string"
    },
    "diffs": [
      {
        "bigmap": 0,
        "path": "string",
        "action": "string",
        "content": {
          "hash": "string"
        }
      }
    ],
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "hasInternals": true,
    "tokenTransfersCount": 0,
    "ticketTransfersCount": 0,
    "eventsCount": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get transaction status

GET

https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get transaction status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/transactions/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transactions/{hash}/status')
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

true

Get transactions count

GET

https://xtz-index.nownodes.io/v1/operations/transactions/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of transaction operations.

Parameters

anyofAnyOfParameter | nullquery

initiatorAccountParameter | nullquery

Filters transactions by initiator. Allowed fields for .eqx mode: target.

senderAccountParameter | nullquery

Filters transactions by sender. Allowed fields for .eqx mode: target.

targetAccountParameter | nullquery

Filters transactions by target. Allowed fields for .eqx mode: sender, initiator.

amountInt64Parameter | nullquery

Filters transactions by amount (micro tez).

levelInt32Parameter | nullquery

Filters transactions by level.

timestampTimestampParameter | nullquery

Filters transactions by timestamp.

entrypointStringParameter | nullquery

Filters transactions by entrypoint called on the target contract.

parameterJsonParameter | nullquery

statusOperationStatusParameter | nullquery

Filters transactions by operation status (applied, failed, backtracked, skipped).

Response

200OK

Get transactions count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/transactions/count'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/transactions/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transactions/count')
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

Get reveals

GET

https://xtz-index.nownodes.io/v1/operations/reveals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of reveal operations.

Parameters

senderAccountParameter | nullquery

Filters reveal operations by sender. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters reveal operations by level.

timestampDateTimeParameter | nullquery

Filters reveal operations by timestamp.

statusOperationStatusParameter | nullquery

Filters reveal operations by operation status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts reveals by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get reveals

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/reveals'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/reveals', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/reveals')
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://xtz-index.nownodes.io/v1/operations/reveals')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/reveals', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/reveals')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/reveals')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get reveal by hash

GET

https://xtz-index.nownodes.io/v1/operations/reveals/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns reveal operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get reveal by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/reveals/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/reveals/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/reveals/{hash}')
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://xtz-index.nownodes.io/v1/operations/reveals/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/reveals/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/reveals/{hash}";
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://xtz-index.nownodes.io/v1/operations/reveals/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/reveals/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/reveals/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get reveal status

GET

https://xtz-index.nownodes.io/v1/operations/reveals/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get reveal status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/reveals/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/reveals/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/reveals/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/reveals/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/reveals/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/reveals/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/reveals/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/reveals/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/reveals/{hash}/status')
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

true

Get reveals count

GET

https://xtz-index.nownodes.io/v1/operations/reveals/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of reveal operations.

Parameters

levelInt32Parameter | nullquery

Filters reveals by level.

timestampDateTimeParameter | nullquery

Filters reveals by timestamp.

Response

200OK

Get reveals count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/reveals/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/reveals/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/reveals/count')
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://xtz-index.nownodes.io/v1/operations/reveals/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/reveals/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/reveals/count";
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://xtz-index.nownodes.io/v1/operations/reveals/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/reveals/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/reveals/count')
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

Get register constants

GET

https://xtz-index.nownodes.io/v1/operations/register_constants

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of register global constant operations.

Parameters

senderAccountParameter | nullquery

Filters operations by sender. Allowed fields for .eqx mode: none.

addressExpressionParameter | nullquery

Filters operations by global address of the created constant (starts with expr..).

levelInt32Parameter | nullquery

Filters operations by level.

timestampDateTimeParameter | nullquery

Filters operations by timestamp.

statusOperationStatusParameter | nullquery

Filters operations by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts operations by specified field. Supported fields: id (default), level, gasUsed, storageUsed, bakerFee, storageFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the constant value: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get register constants

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/register_constants'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/register_constants', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/register_constants')
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://xtz-index.nownodes.io/v1/operations/register_constants')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/register_constants', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/register_constants')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/register_constants')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "status": "string",
    "address": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get register constant by hash

GET

https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns register global constant operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

michelineMichelineFormatJsonquery

Format of the constant value: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get register constant by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}')
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://xtz-index.nownodes.io/v1/operations/register_constants/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}";
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://xtz-index.nownodes.io/v1/operations/register_constants/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "status": "string",
    "address": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get register constant status

GET

https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get register constant status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/register_constants/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/register_constants/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/register_constants/{hash}/status')
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

true

Get register constants count

GET

https://xtz-index.nownodes.io/v1/operations/register_constants/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of register global constant operations.

Parameters

levelInt32Parameter | nullquery

Filters operations by level.

timestampDateTimeParameter | nullquery

Filters operations by timestamp.

Response

200OK

Get register constants count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/register_constants/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/register_constants/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/register_constants/count')
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://xtz-index.nownodes.io/v1/operations/register_constants/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/register_constants/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/register_constants/count";
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://xtz-index.nownodes.io/v1/operations/register_constants/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/register_constants/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/register_constants/count')
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

Get set deposits limits

GET

https://xtz-index.nownodes.io/v1/operations/set_deposits_limits

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of set deposits limit operations.

Parameters

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get set deposits limits

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/set_deposits_limits'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits')
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://xtz-index.nownodes.io/v1/operations/set_deposits_limits')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "status": "string",
    "limit": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get set deposits limit by hash

GET

https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns set deposits limit operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get set deposits limit by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}')
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://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}";
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://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "status": "string",
    "limit": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get set deposits limit status

GET

https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get set deposits limit status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/{hash}/status')
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

true

Get set deposits limits count

GET

https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of set deposits limit operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get set deposits limits count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/count')
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://xtz-index.nownodes.io/v1/operations/set_deposits_limits/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/count";
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://xtz-index.nownodes.io/v1/operations/set_deposits_limits/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/set_deposits_limits/count')
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

Get transfer ticket

GET

https://xtz-index.nownodes.io/v1/operations/transfer_ticket

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of transfer ticket operations.

Parameters

anyofAnyOfParameter | nullquery

Filters by any of the specified fields. Example: anyof.sender.target=tz1... will return operations where sender OR target is equal to the specified value. This parameter is useful when you need to retrieve all operations associated with a specified account.

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

targetAccountParameter | nullquery

Filters by target. Allowed fields for .eqx mode: none.

idInt64Parameter | nullquery

Filters by id.

ticketerAccountParameter | nullquery

Filters by ticketer. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the content value: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get transfer ticket

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/transfer_ticket'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transfer_ticket', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transfer_ticket')
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://xtz-index.nownodes.io/v1/operations/transfer_ticket')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transfer_ticket', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/transfer_ticket')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transfer_ticket')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "target": {
      "alias": "string",
      "address": "string"
    },
    "ticketer": {
      "alias": "string",
      "address": "string"
    },
    "amount": "string",
    "entrypoint": "string",
    "ticketTransfersCount": 0,
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get transfer ticket by hash

GET

https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns transfer ticket operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

michelineMichelineFormatJsonquery

Format of the content value: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get transfer ticket by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}')
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://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}";
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://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "target": {
      "alias": "string",
      "address": "string"
    },
    "ticketer": {
      "alias": "string",
      "address": "string"
    },
    "amount": "string",
    "entrypoint": "string",
    "ticketTransfersCount": 0,
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get transfer ticket status

GET

https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get transfer ticket status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/{hash}/status')
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

true

Get transfer ticket count

GET

https://xtz-index.nownodes.io/v1/operations/transfer_ticket/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of transfer ticket operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get transfer ticket count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/transfer_ticket/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/count')
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://xtz-index.nownodes.io/v1/operations/transfer_ticket/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/transfer_ticket/count";
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://xtz-index.nownodes.io/v1/operations/transfer_ticket/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/transfer_ticket/count')
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

Get tx rollup commit

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of tx rollup commit operations.

Parameters

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

rollupAccountParameter | nullquery

Filters by rollup. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup commit

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_commit')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "bond": 0,
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup commit by hash

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns tx rollup commit operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup commit by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "bond": 0,
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup commit status

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get tx rollup commit status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/{hash}/status')
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

true

Get tx rollup commit count

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of tx rollup commit operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get tx rollup commit count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/count')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/count";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_commit/count')
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

Get tx rollup dispatch tickets

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of tx rollup dispatch tickets operations.

Parameters

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

rollupAccountParameter | nullquery

Filters by rollup. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup dispatch tickets

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup dispatch tickets by hash

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns tx rollup dispatch tickets operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup dispatch tickets by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup dispatch tickets status

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get tx rollup dispatch tickets status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/{hash}/status')
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

true

Get tx rollup dispatch tickets count

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of tx rollup dispatch tickets operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get tx rollup dispatch tickets count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/count')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/count";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_dispatch_tickets/count')
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

Get tx rollup finalize commitment

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of tx rollup finalize commitment operations.

Parameters

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

rollupAccountParameter | nullquery

Filters by rollup. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup finalize commitment

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup finalize commitment by hash

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns tx rollup finalize commitment operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup finalize commitment by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup finalize commitment status

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get tx rollup finalize commitment status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/{hash}/status')
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

true

Get tx rollup finalize commitment count

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of tx rollup finalize commitment operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get tx rollup finalize commitment count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/count')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/count";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_finalize_commitment/count')
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

Get tx rollup origination

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of tx rollup origination operations.

Parameters

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

rollupAccountParameter | nullquery

Filters by rollup. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup origination

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_origination')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "allocationFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup origination by hash

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns tx rollup origination operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup origination by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "allocationFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup origination status

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get tx rollup origination status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/{hash}/status')
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

true

Get tx rollup origination count

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of tx rollup origination operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get tx rollup origination count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/count')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/count";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_origination/count')
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

Get tx rollup rejection

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of tx rollup rejection operations.

Parameters

anyofAnyOfParameter | nullquery

Filters by any of the specified fields. Example: anyof.sender.committer=tz1... will return operations where sender OR committer is equal to the specified value. This parameter is useful when you need to retrieve all operations associated with a specified account.

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

committerAccountParameter | nullquery

Filters by committer. Allowed fields for .eqx mode: none.

rollupAccountParameter | nullquery

Filters by rollup. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup rejection

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "committer": {
      "alias": "string",
      "address": "string"
    },
    "reward": 0,
    "loss": 0,
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup rejection by hash

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns tx rollup rejection operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup rejection by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "committer": {
      "alias": "string",
      "address": "string"
    },
    "reward": 0,
    "loss": 0,
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup rejection status

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get tx rollup rejection status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/{hash}/status')
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

true

Get tx rollup rejection count

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of tx rollup rejection operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get tx rollup rejection count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/count')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/count";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_rejection/count')
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

Get tx rollup remove commitment

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of tx rollup remove commitment operations.

Parameters

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

rollupAccountParameter | nullquery

Filters by rollup. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup remove commitment

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup remove commitment by hash

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns tx rollup remove commitment operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup remove commitment by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup remove commitment status

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get tx rollup remove commitment status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/{hash}/status')
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

true

Get tx rollup remove commitment count

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of tx rollup remove commitment operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get tx rollup remove commitment count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/count')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/count";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_remove_commitment/count')
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

Get tx rollup return bond

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of tx rollup return bond operations.

Parameters

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

rollupAccountParameter | nullquery

Filters by rollup. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup return bond

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "bond": 0,
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup return bond by hash

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns tx rollup return bond operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup return bond by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "bond": 0,
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup return bond status

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get tx rollup return bond status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/{hash}/status')
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

true

Get tx rollup return bond count

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of tx rollup return bond operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get tx rollup return bond count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/count')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/count";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_return_bond/count')
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

Get tx rollup submit batch

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of tx rollup submit batch operations.

Parameters

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

rollupAccountParameter | nullquery

Filters by rollup. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level, gasUsed, bakerFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup submit batch

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup submit batch by hash

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns tx rollup submit batch operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get tx rollup submit batch by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get tx rollup submit batch status

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}/status

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns operation status: true if applied, false if failed, null (or HTTP 204) if doesn't exist.

Parameters

hashstringrequiredpath

Operation hash

Response

200OK

Get tx rollup submit batch status

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}/status'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}/status')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}/status')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}/status";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}/status', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}/status')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/{hash}/status')
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

true

Get tx rollup submit batch count

GET

https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of tx rollup submit batch operations.

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get tx rollup submit batch count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/count')
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://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/count";
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://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/tx_rollup_submit_batch/count')
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

Get increase paid storage

GET

https://xtz-index.nownodes.io/v1/operations/increase_paid_storage

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of increase paid storage operations.

Parameters

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

contractAccountParameter | nullquery

Filters by contract. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts operations by specified field. Supported fields: id (default), level, gasUsed, storageUsed, bakerFee, storageFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get increase paid storage

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/increase_paid_storage'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage')
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://xtz-index.nownodes.io/v1/operations/increase_paid_storage')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "status": "string",
    "contract": {
      "alias": "string",
      "address": "string"
    },
    "amount": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get increase paid storage by hash

GET

https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns increase paid storage operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get increase paid storage by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/{hash}')
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://xtz-index.nownodes.io/v1/operations/increase_paid_storage/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/{hash}";
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://xtz-index.nownodes.io/v1/operations/increase_paid_storage/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "status": "string",
    "contract": {
      "alias": "string",
      "address": "string"
    },
    "amount": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get increase paid storage count

GET

https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of increase paid storage operations.

Parameters

levelInt32Parameter | nullquery

Filters operations by level.

timestampDateTimeParameter | nullquery

Filters operations by timestamp.

Response

200OK

Get increase paid storage count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/count')
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://xtz-index.nownodes.io/v1/operations/increase_paid_storage/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/count";
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://xtz-index.nownodes.io/v1/operations/increase_paid_storage/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/increase_paid_storage/count')
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

Get update consensus key

GET

https://xtz-index.nownodes.io/v1/operations/update_consensus_key

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of update consensus key operations.

Parameters

senderAccountParameter | nullquery

Filters by sender. Allowed fields for .eqx mode: none.

activationCycleInt32Parameter | nullquery

Filters by activation cycle. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

statusOperationStatusParameter | nullquery

Filters by status (applied, failed, backtracked, skipped).

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts operations by specified field. Supported fields: id (default), level, gasUsed, storageUsed, bakerFee, storageFee.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get update consensus key

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/update_consensus_key'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/update_consensus_key', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/update_consensus_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://xtz-index.nownodes.io/v1/operations/update_consensus_key')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/update_consensus_key', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/update_consensus_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://xtz-index.nownodes.io/v1/operations/update_consensus_key', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/update_consensus_key')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/update_consensus_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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "status": "string",
    "activationCycle": 0,
    "publicKey": "string",
    "publicKeyHash": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get update consensus key by hash

GET

https://xtz-index.nownodes.io/v1/operations/update_consensus_key/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns update consensus key operation with specified hash.

Parameters

hashstringrequiredpath

Operation hash

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get update consensus key by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/update_consensus_key/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/update_consensus_key/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/update_consensus_key/{hash}')
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://xtz-index.nownodes.io/v1/operations/update_consensus_key/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/update_consensus_key/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/update_consensus_key/{hash}";
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://xtz-index.nownodes.io/v1/operations/update_consensus_key/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/update_consensus_key/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/update_consensus_key/{hash}')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "status": "string",
    "activationCycle": 0,
    "publicKey": "string",
    "publicKeyHash": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get update consensus key count

GET

https://xtz-index.nownodes.io/v1/operations/update_consensus_key/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of update consensus key operations.

Parameters

levelInt32Parameter | nullquery

Filters operations by level.

timestampDateTimeParameter | nullquery

Filters operations by timestamp.

Response

200OK

Get update consensus key count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/update_consensus_key/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/update_consensus_key/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/update_consensus_key/count')
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://xtz-index.nownodes.io/v1/operations/update_consensus_key/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/update_consensus_key/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/update_consensus_key/count";
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://xtz-index.nownodes.io/v1/operations/update_consensus_key/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/update_consensus_key/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/update_consensus_key/count')
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

Get smart rollup add messages

GET

https://xtz-index.nownodes.io/v1/operations/sr_add_messages

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollup add messages operations.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get smart rollup add messages

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_add_messages'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_add_messages', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_add_messages')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_add_messages')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_add_messages', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/sr_add_messages";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_add_messages', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_add_messages')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_add_messages')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "status": "string",
    "messagesCount": 0,
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get smart rollup add messages count

GET

https://xtz-index.nownodes.io/v1/operations/sr_add_messages/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of smart rollup add messages operations.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

Response

200OK

Get smart rollup add messages count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_add_messages/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_add_messages/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_add_messages/count')
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://xtz-index.nownodes.io/v1/operations/sr_add_messages/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_add_messages/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/sr_add_messages/count";
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://xtz-index.nownodes.io/v1/operations/sr_add_messages/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_add_messages/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_add_messages/count')
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

Get smart rollup cement

GET

https://xtz-index.nownodes.io/v1/operations/sr_cement

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollup cement operations.

Parameters

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get smart rollup cement

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_cement'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_cement', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_cement')
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://xtz-index.nownodes.io/v1/operations/sr_cement')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_cement', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_cement')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_cement')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "status": "string",
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "commitment": {
      "id": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "inboxLevel": 0,
      "state": "string",
      "hash": "string",
      "ticks": 0,
      "firstLevel": 0,
      "firstTime": "2024-01-15T09:30:00Z"
    },
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get smart rollup cement count

GET

https://xtz-index.nownodes.io/v1/operations/sr_cement/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of smart rollup cement operations.

Parameters

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

Response

200OK

Get smart rollup cement count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_cement/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_cement/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_cement/count')
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://xtz-index.nownodes.io/v1/operations/sr_cement/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_cement/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/sr_cement/count";
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://xtz-index.nownodes.io/v1/operations/sr_cement/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_cement/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_cement/count')
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

Get smart rollup execute

GET

https://xtz-index.nownodes.io/v1/operations/sr_execute

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollup execute operations.

Parameters

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get smart rollup execute

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_execute'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_execute', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_execute')
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://xtz-index.nownodes.io/v1/operations/sr_execute')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_execute', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_execute')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_execute')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "status": "string",
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "commitment": {
      "id": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "inboxLevel": 0,
      "state": "string",
      "hash": "string",
      "ticks": 0,
      "firstLevel": 0,
      "firstTime": "2024-01-15T09:30:00Z"
    },
    "errors": [
      {
        "type": "string"
      }
    ],
    "ticketTransfersCount": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get smart rollup execute count

GET

https://xtz-index.nownodes.io/v1/operations/sr_execute/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of smart rollup execute operations.

Parameters

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

Response

200OK

Get smart rollup execute count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_execute/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_execute/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_execute/count')
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://xtz-index.nownodes.io/v1/operations/sr_execute/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_execute/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/sr_execute/count";
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://xtz-index.nownodes.io/v1/operations/sr_execute/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_execute/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_execute/count')
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

Get smart rollup originate

GET

https://xtz-index.nownodes.io/v1/operations/sr_originate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollup originate operations.

Parameters

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

michelineMichelineFormatJsonquery

Format of the parameter type value: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

Response

200OK

Get smart rollup originate

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_originate'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_originate', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_originate')
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://xtz-index.nownodes.io/v1/operations/sr_originate')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_originate', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_originate')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_originate')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "storageUsed": 0,
    "bakerFee": 0,
    "storageFee": 0,
    "status": "string",
    "pvmKind": "string",
    "kernel": "dGVzdA==",
    "genesisCommitment": "string",
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get smart rollup originate count

GET

https://xtz-index.nownodes.io/v1/operations/sr_originate/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of smart rollup originate operations.

Parameters

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

Response

200OK

Get smart rollup originate count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_originate/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_originate/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_originate/count')
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://xtz-index.nownodes.io/v1/operations/sr_originate/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_originate/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/sr_originate/count";
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://xtz-index.nownodes.io/v1/operations/sr_originate/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_originate/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_originate/count')
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

Get smart rollup publish

GET

https://xtz-index.nownodes.io/v1/operations/sr_publish

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollup publish operations.

Parameters

commitment.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

commitment.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get smart rollup publish

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_publish'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_publish', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_publish')
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://xtz-index.nownodes.io/v1/operations/sr_publish')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_publish', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_publish')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_publish')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "status": "string",
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "commitment": {
      "id": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "inboxLevel": 0,
      "state": "string",
      "hash": "string",
      "ticks": 0,
      "firstLevel": 0,
      "firstTime": "2024-01-15T09:30:00Z"
    },
    "bond": 0,
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get smart rollup publish count

GET

https://xtz-index.nownodes.io/v1/operations/sr_publish/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of smart rollup publish operations.

Parameters

commitment.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

commitment.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

Response

200OK

Get smart rollup publish count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_publish/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_publish/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_publish/count')
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://xtz-index.nownodes.io/v1/operations/sr_publish/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_publish/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/sr_publish/count";
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://xtz-index.nownodes.io/v1/operations/sr_publish/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_publish/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_publish/count')
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

Get smart rollup recover bond

GET

https://xtz-index.nownodes.io/v1/operations/sr_recover_bond

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollup recover bond operations.

Parameters

anyofAnyOfParameter | nullquery

Filter by any of the specified fields (sender or staker). Example: anyof.sender.staker=tz1... will return operations where sender OR staker is equal to the specified value. This parameter is useful when you need to get all operations somehow related to the account in a single request.
Click on the parameter to expand more details.

stakerAccountParameter | nullquery

Filter by staker address.
Click on the parameter to expand more details.

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get smart rollup recover bond

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_recover_bond'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_recover_bond', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_recover_bond')
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://xtz-index.nownodes.io/v1/operations/sr_recover_bond')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_recover_bond', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_recover_bond')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_recover_bond')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "status": "string",
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "staker": {
      "alias": "string",
      "address": "string"
    },
    "bond": 0,
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get smart rollup recover bond count

GET

https://xtz-index.nownodes.io/v1/operations/sr_recover_bond/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of smart rollup recover bond operations.

Parameters

anyofAnyOfParameter | nullquery

stakerAccountParameter | nullquery

Filter by staker address.
Click on the parameter to expand more details.

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

Response

200OK

Get smart rollup recover bond count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_recover_bond/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_recover_bond/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_recover_bond/count')
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://xtz-index.nownodes.io/v1/operations/sr_recover_bond/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_recover_bond/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/sr_recover_bond/count";
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://xtz-index.nownodes.io/v1/operations/sr_recover_bond/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_recover_bond/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_recover_bond/count')
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

Get smart rollup refute

GET

https://xtz-index.nownodes.io/v1/operations/sr_refute

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollup refute operations.

Parameters

anyofAnyOfParameter | nullquery

Filter by any of the specified fields (sender, initiator, or opponent). Example: anyof.initiator.opponent=tz1... will return operations where initiator OR opponent is equal to the specified value. This parameter is useful when you need to get all operations somehow related to the account in a single request.
Click on the parameter to expand more details.

game.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

game.initiatorAccountParameter | nullquery

Filter by initiator (who found a wrong commitment and started the refutation game).
Click on the parameter to expand more details.

game.initiatorCommitment.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

game.initiatorCommitment.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

game.opponentAccountParameter | nullquery

Filter by opponent (who was accused in publishing a wrong commitment).
Click on the parameter to expand more details.

game.opponentCommitment.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

game.opponentCommitment.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

moveRefutationMoveParameter | nullquery

Filter by refutation game move (start, dissection, proof, or timeout).
Click on the parameter to expand more details.

gameStatusRefutationGameStatusParameter | nullquery

Filter by refutation game status (none, ongoing, loser, or draw).
Click on the parameter to expand more details.

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get smart rollup refute

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_refute'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_refute', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_refute')
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://xtz-index.nownodes.io/v1/operations/sr_refute')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_refute', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_refute')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_refute')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "status": "string",
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "game": {
      "id": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "initiatorCommitment": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "inboxLevel": 0,
        "state": "string",
        "hash": "string",
        "ticks": 0,
        "firstLevel": 0,
        "firstTime": "2024-01-15T09:30:00Z"
      },
      "opponent": {
        "alias": "string",
        "address": "string"
      },
      "opponentCommitment": {
        "id": 0,
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "inboxLevel": 0,
        "state": "string",
        "hash": "string",
        "ticks": 0,
        "firstLevel": 0,
        "firstTime": "2024-01-15T09:30:00Z"
      },
      "initiatorReward": 0,
      "initiatorLoss": 0,
      "opponentReward": 0,
      "opponentLoss": 0
    },
    "move": "string",
    "gameStatus": "string",
    "dissectionStart": 0,
    "dissectionEnd": 0,
    "dissectionSteps": 0,
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get smart rollup refute count

GET

https://xtz-index.nownodes.io/v1/operations/sr_refute/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of smart rollup refute operations.

Parameters

anyofAnyOfParameter | nullquery

game.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

game.initiatorAccountParameter | nullquery

Filter by initiator (who found a wrong commitment and started the refutation game).
Click on the parameter to expand more details.

game.initiatorCommitment.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

game.initiatorCommitment.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

game.opponentAccountParameter | nullquery

Filter by opponent (who was accused in publishing a wrong commitment).
Click on the parameter to expand more details.

game.opponentCommitment.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

game.opponentCommitment.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

moveRefutationMoveParameter | nullquery

Filter by refutation game move (start, dissection, proof, or timeout).
Click on the parameter to expand more details.

gameStatusRefutationGameStatusParameter | nullquery

Filter by refutation game status (none, ongoing, loser, or draw).
Click on the parameter to expand more details.

rollupSmartRollupParameter | nullquery

Filter by rollup address.
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

Response

200OK

Get smart rollup refute count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/sr_refute/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_refute/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_refute/count')
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://xtz-index.nownodes.io/v1/operations/sr_refute/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/sr_refute/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/sr_refute/count";
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://xtz-index.nownodes.io/v1/operations/sr_refute/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/sr_refute/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/sr_refute/count')
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

Get staking ops

GET

https://xtz-index.nownodes.io/v1/operations/staking

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of staking operations.

Parameters

anyofAnyOfParameter | nullquery

Filter by any of the specified fields (sender, or baker). Example: anyof.sender.baker=tz1... will return operations where sender OR baker is equal to the specified value. This parameter is useful when you need to get all operations somehow related to the account in a single request.
Click on the parameter to expand more details.

bakerAccountParameter | nullquery

Filter by baker address.
Click on the parameter to expand more details.

kindStakingOperationKindParameter | nullquery

Filter by operation kind (stake, unstake, finalize, or set_parameters).
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get staking ops

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/staking'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/staking', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/staking')
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://xtz-index.nownodes.io/v1/operations/staking')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/staking', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/staking')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/staking')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "hash": "string",
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "counter": 0,
    "gasLimit": 0,
    "gasUsed": 0,
    "storageLimit": 0,
    "bakerFee": 0,
    "kind": "string",
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "amount": 0,
    "pseudotokens": 0,
    "limitOfStakingOverBaking": 0,
    "edgeOfBakingOverStaking": 0,
    "activationCycle": 0,
    "status": "string",
    "errors": [
      {
        "type": "string"
      }
    ],
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get staking ops count

GET

https://xtz-index.nownodes.io/v1/operations/staking/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of staking operations.

Parameters

anyofAnyOfParameter | nullquery

bakerAccountParameter | nullquery

Filter by baker address.
Click on the parameter to expand more details.

kindStakingOperationKindParameter | nullquery

Filter by operation kind (stake, unstake, finalize, or set_parameters).
Click on the parameter to expand more details.

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

hashOpHashParameter | nullquery

Filter by operation hash.
Click on the parameter to expand more details.

counterInt32Parameter | nullquery

Filter by operation counter.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by the domain level.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the operation.
Click on the parameter to expand more details.

statusOperationStatusParameter | nullquery

Filter by operation status (applied, failed, backtracked, skipped).
Click on the parameter to expand more details.

senderAccountParameter | nullquery

Filter by operation sender address.
Click on the parameter to expand more details.

Response

200OK

Get staking ops count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/staking/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/staking/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/staking/count')
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://xtz-index.nownodes.io/v1/operations/staking/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/staking/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/staking/count";
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://xtz-index.nownodes.io/v1/operations/staking/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/staking/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/staking/count')
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

Get migrations

GET

https://xtz-index.nownodes.io/v1/operations/migrations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of migration operations (synthetic type).

Parameters

accountAccountParameter | nullquery

Filters migration operations by account. Allowed fields for .eqx mode: none.

kindMigrationKindParameter | nullquery

Filters migration operations by kind (bootstrap, activate_delegate, airdrop, proposal_invoice, origination, subsidy, remove_bigmap_key).

balanceChangeInt64Parameter | nullquery

Filters migration operations by amount.

idInt64Parameter | nullquery

Filters migration operations by internal TzKT id.

levelInt32Parameter | nullquery

Filters migration operations by level.

timestampDateTimeParameter | nullquery

Filters migration operations by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts migrations by specified field. Supported fields: id (default), level.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get migrations

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/migrations'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/migrations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/migrations')
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://xtz-index.nownodes.io/v1/operations/migrations')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/migrations', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/migrations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/migrations')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "kind": "string",
    "account": {
      "alias": "string",
      "address": "string"
    },
    "balanceChange": 0,
    "diffs": [
      {
        "bigmap": 0,
        "path": "string",
        "action": "string",
        "content": {
          "hash": "string"
        }
      }
    ],
    "tokenTransfersCount": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get migration by id

GET

https://xtz-index.nownodes.io/v1/operations/migrations/{id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns migration operation with specified id.

Parameters

idinteger<int64>requiredpath

Operation id

michelineMichelineFormatJsonquery

Format of the parameters, storage and diffs: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get migration by id

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/migrations/{id}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/migrations/{id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/migrations/{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://xtz-index.nownodes.io/v1/operations/migrations/{id}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/migrations/{id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/migrations/{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://xtz-index.nownodes.io/v1/operations/migrations/{id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/migrations/{id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/migrations/{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

{
  "type": "string",
  "id": 0,
  "level": 0,
  "timestamp": "2024-01-15T09:30:00Z",
  "block": "string",
  "kind": "string",
  "account": {
    "alias": "string",
    "address": "string"
  },
  "balanceChange": 0,
  "diffs": [
    {
      "bigmap": 0,
      "path": "string",
      "action": "string",
      "content": {
        "hash": "string"
      }
    }
  ],
  "tokenTransfersCount": 0,
  "quote": {
    "btc": 0,
    "eur": 0,
    "usd": 0,
    "cny": 0,
    "jpy": 0,
    "krw": 0,
    "eth": 0,
    "gbp": 0
  }
}

Get migrations count

GET

https://xtz-index.nownodes.io/v1/operations/migrations/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of migration operations (synthetic type).

Parameters

levelInt32Parameter | nullquery

Filters migrations by level.

timestampDateTimeParameter | nullquery

Filters migrations by timestamp.

Response

200OK

Get migrations count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/migrations/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/migrations/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/migrations/count')
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://xtz-index.nownodes.io/v1/operations/migrations/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/migrations/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/migrations/count";
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://xtz-index.nownodes.io/v1/operations/migrations/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/migrations/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/migrations/count')
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

Get revelation penalties

GET

https://xtz-index.nownodes.io/v1/operations/revelation_penalties

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of revelation penalty operations (synthetic type).

Parameters

idInt64Parameter | nullquery

Filters operations by internal TzKT id.

bakerAccountParameter | nullquery

Filters revelation penalty operations by baker. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters revelation penalty operations by level.

timestampDateTimeParameter | nullquery

Filters revelation penalty operations by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts revelation penalty operations by specified field. Supported fields: id (default), level.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get revelation penalties

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/revelation_penalties'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/revelation_penalties', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/revelation_penalties')
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://xtz-index.nownodes.io/v1/operations/revelation_penalties')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/revelation_penalties', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/revelation_penalties')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/revelation_penalties')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "missedLevel": 0,
    "loss": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "lostReward": 0,
    "lostFees": 0
  }
]

Get revelation penalty by id

GET

https://xtz-index.nownodes.io/v1/operations/revelation_penalties/{id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns revelation penalty operation with specified id.

Parameters

idinteger<int64>requiredpath

Operation id

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get revelation penalty by id

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/revelation_penalties/{id}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/revelation_penalties/{id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/revelation_penalties/{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://xtz-index.nownodes.io/v1/operations/revelation_penalties/{id}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/revelation_penalties/{id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/revelation_penalties/{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://xtz-index.nownodes.io/v1/operations/revelation_penalties/{id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/revelation_penalties/{id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/revelation_penalties/{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

{
  "type": "string",
  "id": 0,
  "level": 0,
  "timestamp": "2024-01-15T09:30:00Z",
  "block": "string",
  "baker": {
    "alias": "string",
    "address": "string"
  },
  "missedLevel": 0,
  "loss": 0,
  "quote": {
    "btc": 0,
    "eur": 0,
    "usd": 0,
    "cny": 0,
    "jpy": 0,
    "krw": 0,
    "eth": 0,
    "gbp": 0
  },
  "lostReward": 0,
  "lostFees": 0
}

Get revelation penalties count

GET

https://xtz-index.nownodes.io/v1/operations/revelation_penalties/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of revelation penalty operations (synthetic type).

Parameters

levelInt32Parameter | nullquery

Filters revelation penalty operations by level.

timestampDateTimeParameter | nullquery

Filters revelation penalty operations by timestamp.

Response

200OK

Get revelation penalties count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/revelation_penalties/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/revelation_penalties/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/revelation_penalties/count')
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://xtz-index.nownodes.io/v1/operations/revelation_penalties/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/revelation_penalties/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/revelation_penalties/count";
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://xtz-index.nownodes.io/v1/operations/revelation_penalties/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/revelation_penalties/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/revelation_penalties/count')
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

Get baking

GET

https://xtz-index.nownodes.io/v1/operations/baking

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of baking operations (synthetic type).

Parameters

bakerAccountParameter | nullquery

[DEPRECATED]

anyofAnyOfParameter | nullquery

Filters by any of the specified fields. Example: anyof.proposer.producer=tz1....

proposerAccountParameter | nullquery

Filters by block proposer. Allowed fields for .eqx mode: none.

producerAccountParameter | nullquery

Filters by block producer. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters baking operations by level.

timestampDateTimeParameter | nullquery

Filters baking operations by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts baking operations by specified field. Supported fields: id (default), level.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get baking

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/baking'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/baking', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/baking')
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://xtz-index.nownodes.io/v1/operations/baking')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/baking', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/baking')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/baking')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "proposer": {
      "alias": "string",
      "address": "string"
    },
    "producer": {
      "alias": "string",
      "address": "string"
    },
    "payloadRound": 0,
    "blockRound": 0,
    "deposit": 0,
    "rewardLiquid": 0,
    "rewardStakedOwn": 0,
    "rewardStakedShared": 0,
    "bonusLiquid": 0,
    "bonusStakedOwn": 0,
    "bonusStakedShared": 0,
    "fees": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "reward": 0,
    "bonus": 0,
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "priority": 0
  }
]

Get baking by id

GET

https://xtz-index.nownodes.io/v1/operations/baking/{id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns baking operation with specified id.

Parameters

idinteger<int64>requiredpath

Operation id

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get baking by id

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/baking/{id}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/baking/{id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/baking/{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://xtz-index.nownodes.io/v1/operations/baking/{id}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/baking/{id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/baking/{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://xtz-index.nownodes.io/v1/operations/baking/{id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/baking/{id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/baking/{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

{
  "type": "string",
  "id": 0,
  "level": 0,
  "timestamp": "2024-01-15T09:30:00Z",
  "block": "string",
  "proposer": {
    "alias": "string",
    "address": "string"
  },
  "producer": {
    "alias": "string",
    "address": "string"
  },
  "payloadRound": 0,
  "blockRound": 0,
  "deposit": 0,
  "rewardLiquid": 0,
  "rewardStakedOwn": 0,
  "rewardStakedShared": 0,
  "bonusLiquid": 0,
  "bonusStakedOwn": 0,
  "bonusStakedShared": 0,
  "fees": 0,
  "quote": {
    "btc": 0,
    "eur": 0,
    "usd": 0,
    "cny": 0,
    "jpy": 0,
    "krw": 0,
    "eth": 0,
    "gbp": 0
  },
  "reward": 0,
  "bonus": 0,
  "baker": {
    "alias": "string",
    "address": "string"
  },
  "priority": 0
}

Get baking count

GET

https://xtz-index.nownodes.io/v1/operations/baking/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of baking operations (synthetic type).

Parameters

levelInt32Parameter | nullquery

Filters baking operations by level.

timestampDateTimeParameter | nullquery

Filters baking operations by timestamp.

Response

200OK

Get baking count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/baking/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/baking/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/baking/count')
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://xtz-index.nownodes.io/v1/operations/baking/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/baking/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/baking/count";
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://xtz-index.nownodes.io/v1/operations/baking/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/baking/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/baking/count')
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

Get endorsing rewards

GET

https://xtz-index.nownodes.io/v1/operations/endorsing_rewards

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of endorsing reward operations (synthetic type).

Parameters

idInt64Parameter | nullquery

Filters operations by internal TzKT id.

bakerAccountParameter | nullquery

Filters by baker. Allowed fields for .eqx mode: none.

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts by specified field. Supported fields: id (default), level.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get endorsing rewards

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/endorsing_rewards'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/endorsing_rewards";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "block": "string",
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "expected": 0,
    "rewardLiquid": 0,
    "rewardStakedOwn": 0,
    "rewardStakedShared": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "received": 0
  }
]

Get endorsing reward by id

GET

https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/{id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns endorsing reward operation with specified id.

Parameters

idinteger<int64>requiredpath

Operation id

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get endorsing reward by id

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/{id}'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/{id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/{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://xtz-index.nownodes.io/v1/operations/endorsing_rewards/{id}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/{id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/{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://xtz-index.nownodes.io/v1/operations/endorsing_rewards/{id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/{id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/{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

{
  "type": "string",
  "id": 0,
  "level": 0,
  "timestamp": "2024-01-15T09:30:00Z",
  "block": "string",
  "baker": {
    "alias": "string",
    "address": "string"
  },
  "expected": 0,
  "rewardLiquid": 0,
  "rewardStakedOwn": 0,
  "rewardStakedShared": 0,
  "quote": {
    "btc": 0,
    "eur": 0,
    "usd": 0,
    "cny": 0,
    "jpy": 0,
    "krw": 0,
    "eth": 0,
    "gbp": 0
  },
  "received": 0
}

Get endorsing rewards count

GET

https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of endorsing reward operations (synthetic type).

Parameters

levelInt32Parameter | nullquery

Filters by level.

timestampDateTimeParameter | nullquery

Filters by timestamp.

Response

200OK

Get endorsing rewards count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/count')
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://xtz-index.nownodes.io/v1/operations/endorsing_rewards/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/count";
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://xtz-index.nownodes.io/v1/operations/endorsing_rewards/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/endorsing_rewards/count')
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

Get autostaking ops

GET

https://xtz-index.nownodes.io/v1/operations/autostaking

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of autostaking operations.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by level of the block where the operation happened.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the operation happened.
Click on the parameter to expand more details.

bakerAccountParameter | nullquery

Filter by baker.
Click on the parameter to expand more details.

actionAutostakingActionParameter | nullquery

Filter by autostaking action.
Click on the parameter to expand more details.

cycleInt32Parameter | nullquery

Filter by cycle.
Click on the parameter to expand more details.

amountInt64Parameter | nullquery

Filter by amount.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get autostaking ops

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/autostaking'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/autostaking', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/autostaking')
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://xtz-index.nownodes.io/v1/operations/autostaking')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/autostaking', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/autostaking')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/autostaking')
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

[
  {
    "type": "string",
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "action": "string",
    "cycle": 0,
    "amount": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    }
  }
]

Get autostaking ops count

GET

https://xtz-index.nownodes.io/v1/operations/autostaking/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of autostaking operations.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by level of the block where the operation happened.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the operation happened.
Click on the parameter to expand more details.

bakerAccountParameter | nullquery

Filter by baker.
Click on the parameter to expand more details.

actionAutostakingActionParameter | nullquery

Filter by autostaking action.
Click on the parameter to expand more details.

cycleInt32Parameter | nullquery

Filter by cycle.
Click on the parameter to expand more details.

amountInt64Parameter | nullquery

Filter by amount.
Click on the parameter to expand more details.

Response

200OK

Get autostaking ops count

curl -X GET 'https://xtz-index.nownodes.io/v1/operations/autostaking/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/autostaking/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/autostaking/count')
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://xtz-index.nownodes.io/v1/operations/autostaking/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/operations/autostaking/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/operations/autostaking/count";
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://xtz-index.nownodes.io/v1/operations/autostaking/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/operations/autostaking/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/operations/autostaking/count')
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

Protocols

Get protocols count

GET

https://xtz-index.nownodes.io/v1/protocols/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of protocols.

Response

200OK

Get protocols count

curl -X GET 'https://xtz-index.nownodes.io/v1/protocols/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/protocols/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/protocols/count')
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://xtz-index.nownodes.io/v1/protocols/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/protocols/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/protocols/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/protocols/count')
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

Get protocols

GET

https://xtz-index.nownodes.io/v1/protocols

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of protocols.

Parameters

sortSortParameter | nullquery

Sorts protocols by specified field. Supported fields: code (default), firstLevel, lastLevel.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get protocols

curl -X GET 'https://xtz-index.nownodes.io/v1/protocols'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/protocols')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/protocols')
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": 0,
    "hash": "string",
    "firstLevel": 0,
    "firstCycle": 0,
    "firstCycleLevel": 0,
    "lastLevel": 0,
    "constants": {
      "rampUpCycles": 0,
      "noRewardCycles": 0,
      "preservedCycles": 0,
      "blocksPerCycle": 0,
      "blocksPerCommitment": 0,
      "blocksPerSnapshot": 0,
      "blocksPerVoting": 0,
      "timeBetweenBlocks": 0,
      "endorsersPerBlock": 0,
      "hardOperationGasLimit": 0,
      "hardOperationStorageLimit": 0,
      "hardBlockGasLimit": 0,
      "minimalStake": 0,
      "minimalFrozenStake": 0,
      "blockDeposit": 0,
      "blockReward": [
        0
      ],
      "endorsementDeposit": 0,
      "endorsementReward": [
        0
      ],
      "originationSize": 0,
      "byteCost": 0,
      "proposalQuorum": 0,
      "ballotQuorumMin": 0,
      "ballotQuorumMax": 0,
      "lbToggleThreshold": 0,
      "consensusThreshold": 0,
      "minParticipationNumerator": 0,
      "minParticipationDenominator": 0,
      "maxSlashingPeriod": 0,
      "maxDelegatedOverFrozenRatio": 0,
      "maxExternalOverOwnStakeRatio": 0,
      "smartRollupOriginationSize": 0,
      "smartRollupStakeAmount": 0,
      "smartRollupChallengeWindow": 0,
      "smartRollupCommitmentPeriod": 0,
      "smartRollupTimeoutPeriod": 0,
      "dictator": "string",
      "lbEscapeThreshold": 0,
      "lbSunsetLevel": 0,
      "frozenDepositsPercentage": 0,
      "txRollupOriginationSize": 0,
      "txRollupCommitmentBond": 0,
      "doubleBakingPunishment": 0,
      "doubleEndorsingPunishmentNumerator": 0,
      "doubleEndorsingPunishmentDenominator": 0,
      "revelationReward": 0,
      "lbSubsidy": 0,
      "tokensPerRoll": 0
    }
  }
]

Get current protocol

GET

https://xtz-index.nownodes.io/v1/protocols/current

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns current protocol.

Response

200OK

Get current protocol

curl -X GET 'https://xtz-index.nownodes.io/v1/protocols/current'

const response = await fetch('https://xtz-index.nownodes.io/v1/protocols/current', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/protocols/current')
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://xtz-index.nownodes.io/v1/protocols/current')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/protocols/current', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/protocols/current')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/protocols/current')
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": 0,
  "hash": "string",
  "firstLevel": 0,
  "firstCycle": 0,
  "firstCycleLevel": 0,
  "lastLevel": 0,
  "constants": {
    "rampUpCycles": 0,
    "noRewardCycles": 0,
    "preservedCycles": 0,
    "blocksPerCycle": 0,
    "blocksPerCommitment": 0,
    "blocksPerSnapshot": 0,
    "blocksPerVoting": 0,
    "timeBetweenBlocks": 0,
    "endorsersPerBlock": 0,
    "hardOperationGasLimit": 0,
    "hardOperationStorageLimit": 0,
    "hardBlockGasLimit": 0,
    "minimalStake": 0,
    "minimalFrozenStake": 0,
    "blockDeposit": 0,
    "blockReward": [
      0
    ],
    "endorsementDeposit": 0,
    "endorsementReward": [
      0
    ],
    "originationSize": 0,
    "byteCost": 0,
    "proposalQuorum": 0,
    "ballotQuorumMin": 0,
    "ballotQuorumMax": 0,
    "lbToggleThreshold": 0,
    "consensusThreshold": 0,
    "minParticipationNumerator": 0,
    "minParticipationDenominator": 0,
    "maxSlashingPeriod": 0,
    "maxDelegatedOverFrozenRatio": 0,
    "maxExternalOverOwnStakeRatio": 0,
    "smartRollupOriginationSize": 0,
    "smartRollupStakeAmount": 0,
    "smartRollupChallengeWindow": 0,
    "smartRollupCommitmentPeriod": 0,
    "smartRollupTimeoutPeriod": 0,
    "dictator": "string",
    "lbEscapeThreshold": 0,
    "lbSunsetLevel": 0,
    "frozenDepositsPercentage": 0,
    "txRollupOriginationSize": 0,
    "txRollupCommitmentBond": 0,
    "doubleBakingPunishment": 0,
    "doubleEndorsingPunishmentNumerator": 0,
    "doubleEndorsingPunishmentDenominator": 0,
    "revelationReward": 0,
    "lbSubsidy": 0,
    "tokensPerRoll": 0
  }
}

Get protocol by code

GET

https://xtz-index.nownodes.io/v1/protocols/{code}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a protocol with the specified proto code.

Parameters

codeinteger<int32>requiredpath

Protocol code (e.g. 4 for Athens, 5 for Babylon, etc)

Response

200OK

Get protocol by code

curl -X GET 'https://xtz-index.nownodes.io/v1/protocols/{code}'

const response = await fetch('https://xtz-index.nownodes.io/v1/protocols/{code}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/protocols/{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://xtz-index.nownodes.io/v1/protocols/{code}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/protocols/{code}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/protocols/{code}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/protocols/{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": 0,
  "hash": "string",
  "firstLevel": 0,
  "firstCycle": 0,
  "firstCycleLevel": 0,
  "lastLevel": 0,
  "constants": {
    "rampUpCycles": 0,
    "noRewardCycles": 0,
    "preservedCycles": 0,
    "blocksPerCycle": 0,
    "blocksPerCommitment": 0,
    "blocksPerSnapshot": 0,
    "blocksPerVoting": 0,
    "timeBetweenBlocks": 0,
    "endorsersPerBlock": 0,
    "hardOperationGasLimit": 0,
    "hardOperationStorageLimit": 0,
    "hardBlockGasLimit": 0,
    "minimalStake": 0,
    "minimalFrozenStake": 0,
    "blockDeposit": 0,
    "blockReward": [
      0
    ],
    "endorsementDeposit": 0,
    "endorsementReward": [
      0
    ],
    "originationSize": 0,
    "byteCost": 0,
    "proposalQuorum": 0,
    "ballotQuorumMin": 0,
    "ballotQuorumMax": 0,
    "lbToggleThreshold": 0,
    "consensusThreshold": 0,
    "minParticipationNumerator": 0,
    "minParticipationDenominator": 0,
    "maxSlashingPeriod": 0,
    "maxDelegatedOverFrozenRatio": 0,
    "maxExternalOverOwnStakeRatio": 0,
    "smartRollupOriginationSize": 0,
    "smartRollupStakeAmount": 0,
    "smartRollupChallengeWindow": 0,
    "smartRollupCommitmentPeriod": 0,
    "smartRollupTimeoutPeriod": 0,
    "dictator": "string",
    "lbEscapeThreshold": 0,
    "lbSunsetLevel": 0,
    "frozenDepositsPercentage": 0,
    "txRollupOriginationSize": 0,
    "txRollupCommitmentBond": 0,
    "doubleBakingPunishment": 0,
    "doubleEndorsingPunishmentNumerator": 0,
    "doubleEndorsingPunishmentDenominator": 0,
    "revelationReward": 0,
    "lbSubsidy": 0,
    "tokensPerRoll": 0
  }
}

Get protocol by hash

GET

https://xtz-index.nownodes.io/v1/protocols/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a protocol with the specified hash.

Parameters

hashstringrequiredpath

Protocol hash

Response

200OK

Get protocol by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/protocols/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/protocols/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/protocols/{hash}')
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://xtz-index.nownodes.io/v1/protocols/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/protocols/{hash}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/protocols/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/protocols/{hash}')
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": 0,
  "hash": "string",
  "firstLevel": 0,
  "firstCycle": 0,
  "firstCycleLevel": 0,
  "lastLevel": 0,
  "constants": {
    "rampUpCycles": 0,
    "noRewardCycles": 0,
    "preservedCycles": 0,
    "blocksPerCycle": 0,
    "blocksPerCommitment": 0,
    "blocksPerSnapshot": 0,
    "blocksPerVoting": 0,
    "timeBetweenBlocks": 0,
    "endorsersPerBlock": 0,
    "hardOperationGasLimit": 0,
    "hardOperationStorageLimit": 0,
    "hardBlockGasLimit": 0,
    "minimalStake": 0,
    "minimalFrozenStake": 0,
    "blockDeposit": 0,
    "blockReward": [
      0
    ],
    "endorsementDeposit": 0,
    "endorsementReward": [
      0
    ],
    "originationSize": 0,
    "byteCost": 0,
    "proposalQuorum": 0,
    "ballotQuorumMin": 0,
    "ballotQuorumMax": 0,
    "lbToggleThreshold": 0,
    "consensusThreshold": 0,
    "minParticipationNumerator": 0,
    "minParticipationDenominator": 0,
    "maxSlashingPeriod": 0,
    "maxDelegatedOverFrozenRatio": 0,
    "maxExternalOverOwnStakeRatio": 0,
    "smartRollupOriginationSize": 0,
    "smartRollupStakeAmount": 0,
    "smartRollupChallengeWindow": 0,
    "smartRollupCommitmentPeriod": 0,
    "smartRollupTimeoutPeriod": 0,
    "dictator": "string",
    "lbEscapeThreshold": 0,
    "lbSunsetLevel": 0,
    "frozenDepositsPercentage": 0,
    "txRollupOriginationSize": 0,
    "txRollupCommitmentBond": 0,
    "doubleBakingPunishment": 0,
    "doubleEndorsingPunishmentNumerator": 0,
    "doubleEndorsingPunishmentDenominator": 0,
    "revelationReward": 0,
    "lbSubsidy": 0,
    "tokensPerRoll": 0
  }
}

Get protocol by cycle

GET

https://xtz-index.nownodes.io/v1/protocols/cycles/{cycle}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a protocol at the specified cycle.

Parameters

cycleinteger<int32>requiredpath

Cycle index

Response

200OK

Get protocol by cycle

curl -X GET 'https://xtz-index.nownodes.io/v1/protocols/cycles/{cycle}'

const response = await fetch('https://xtz-index.nownodes.io/v1/protocols/cycles/{cycle}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/protocols/cycles/{cycle}')
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://xtz-index.nownodes.io/v1/protocols/cycles/{cycle}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/protocols/cycles/{cycle}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/protocols/cycles/{cycle}";
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://xtz-index.nownodes.io/v1/protocols/cycles/{cycle}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/protocols/cycles/{cycle}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/protocols/cycles/{cycle}')
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": 0,
  "hash": "string",
  "firstLevel": 0,
  "firstCycle": 0,
  "firstCycleLevel": 0,
  "lastLevel": 0,
  "constants": {
    "rampUpCycles": 0,
    "noRewardCycles": 0,
    "preservedCycles": 0,
    "blocksPerCycle": 0,
    "blocksPerCommitment": 0,
    "blocksPerSnapshot": 0,
    "blocksPerVoting": 0,
    "timeBetweenBlocks": 0,
    "endorsersPerBlock": 0,
    "hardOperationGasLimit": 0,
    "hardOperationStorageLimit": 0,
    "hardBlockGasLimit": 0,
    "minimalStake": 0,
    "minimalFrozenStake": 0,
    "blockDeposit": 0,
    "blockReward": [
      0
    ],
    "endorsementDeposit": 0,
    "endorsementReward": [
      0
    ],
    "originationSize": 0,
    "byteCost": 0,
    "proposalQuorum": 0,
    "ballotQuorumMin": 0,
    "ballotQuorumMax": 0,
    "lbToggleThreshold": 0,
    "consensusThreshold": 0,
    "minParticipationNumerator": 0,
    "minParticipationDenominator": 0,
    "maxSlashingPeriod": 0,
    "maxDelegatedOverFrozenRatio": 0,
    "maxExternalOverOwnStakeRatio": 0,
    "smartRollupOriginationSize": 0,
    "smartRollupStakeAmount": 0,
    "smartRollupChallengeWindow": 0,
    "smartRollupCommitmentPeriod": 0,
    "smartRollupTimeoutPeriod": 0,
    "dictator": "string",
    "lbEscapeThreshold": 0,
    "lbSunsetLevel": 0,
    "frozenDepositsPercentage": 0,
    "txRollupOriginationSize": 0,
    "txRollupCommitmentBond": 0,
    "doubleBakingPunishment": 0,
    "doubleEndorsingPunishmentNumerator": 0,
    "doubleEndorsingPunishmentDenominator": 0,
    "revelationReward": 0,
    "lbSubsidy": 0,
    "tokensPerRoll": 0
  }
}

Quotes

Get quotes count

GET

https://xtz-index.nownodes.io/v1/quotes/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of quotes aligned with blocks.

Response

200OK

Get quotes count

curl -X GET 'https://xtz-index.nownodes.io/v1/quotes/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/quotes/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/quotes/count')
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://xtz-index.nownodes.io/v1/quotes/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/quotes/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/quotes/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/quotes/count')
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

Get last quote

GET

https://xtz-index.nownodes.io/v1/quotes/last

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns last known quote.

Response

200OK

Get last quote

curl -X GET 'https://xtz-index.nownodes.io/v1/quotes/last'

const response = await fetch('https://xtz-index.nownodes.io/v1/quotes/last', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/quotes/last')
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://xtz-index.nownodes.io/v1/quotes/last')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/quotes/last', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/quotes/last')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/quotes/last')
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

{
  "level": 0,
  "timestamp": "2024-01-15T09:30:00Z",
  "btc": 0,
  "eur": 0,
  "usd": 0,
  "cny": 0,
  "jpy": 0,
  "krw": 0,
  "eth": 0,
  "gbp": 0
}

Get quotes

GET

https://xtz-index.nownodes.io/v1/quotes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of quotes aligned with blocks.

Parameters

levelInt32Parameter | nullquery

Filters quotes by level.

timestampDateTimeParameter | nullquery

Filters quotes by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts quotes by specified field. Supported fields: level (default).

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get quotes

curl -X GET 'https://xtz-index.nownodes.io/v1/quotes'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/quotes')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/quotes')
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

[
  {
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "btc": 0,
    "eur": 0,
    "usd": 0,
    "cny": 0,
    "jpy": 0,
    "krw": 0,
    "eth": 0,
    "gbp": 0
  }
]

Rewards

Get baker cycle rewards count

GET

https://xtz-index.nownodes.io/v1/rewards/bakers/{address}/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns total number of cycles where the baker was active

Parameters

addressstringrequiredpath

Baker address

Response

200OK

Get baker cycle rewards count

curl -X GET 'https://xtz-index.nownodes.io/v1/rewards/bakers/{address}/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/bakers/{address}/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/bakers/{address}/count')
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://xtz-index.nownodes.io/v1/rewards/bakers/{address}/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/bakers/{address}/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/rewards/bakers/{address}/count";
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://xtz-index.nownodes.io/v1/rewards/bakers/{address}/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/rewards/bakers/{address}/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/bakers/{address}/count')
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

Get baker cycle rewards

GET

https://xtz-index.nownodes.io/v1/rewards/bakers/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of baker rewards for every cycle, including future cycles.

Parameters

addressstringrequiredpath

Baker address.

cycleInt32Parameter | nullquery

Filters rewards by cycle.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts cycle rewards by specified field. Supported fields: cycle (default, desc).

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get baker cycle rewards

curl -X GET 'https://xtz-index.nownodes.io/v1/rewards/bakers/{address}'

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/bakers/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/bakers/{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://xtz-index.nownodes.io/v1/rewards/bakers/{address}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/bakers/{address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/rewards/bakers/{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://xtz-index.nownodes.io/v1/rewards/bakers/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/rewards/bakers/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/bakers/{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

[
  {
    "cycle": 0,
    "bakingPower": 0,
    "totalBakingPower": 0,
    "ownDelegatedBalance": 0,
    "externalDelegatedBalance": 0,
    "delegatorsCount": 0,
    "ownStakedBalance": 0,
    "externalStakedBalance": 0,
    "stakersCount": 0,
    "expectedBlocks": 0,
    "expectedEndorsements": 0,
    "futureBlocks": 0,
    "futureBlockRewards": 0,
    "blocks": 0,
    "blockRewardsLiquid": 0,
    "blockRewardsStakedOwn": 0,
    "blockRewardsStakedShared": 0,
    "missedBlocks": 0,
    "missedBlockRewards": 0,
    "futureEndorsements": 0,
    "futureEndorsementRewards": 0,
    "endorsements": 0,
    "endorsementRewardsLiquid": 0,
    "endorsementRewardsStakedOwn": 0,
    "endorsementRewardsStakedShared": 0,
    "missedEndorsements": 0,
    "missedEndorsementRewards": 0,
    "blockFees": 0,
    "missedBlockFees": 0,
    "doubleBakingRewards": 0,
    "doubleBakingLostStaked": 0,
    "doubleBakingLostUnstaked": 0,
    "doubleBakingLostExternalStaked": 0,
    "doubleBakingLostExternalUnstaked": 0,
    "doubleEndorsingRewards": 0,
    "doubleEndorsingLostStaked": 0,
    "doubleEndorsingLostUnstaked": 0,
    "doubleEndorsingLostExternalStaked": 0,
    "doubleEndorsingLostExternalUnstaked": 0,
    "doublePreendorsingRewards": 0,
    "doublePreendorsingLostStaked": 0,
    "doublePreendorsingLostUnstaked": 0,
    "doublePreendorsingLostExternalStaked": 0,
    "doublePreendorsingLostExternalUnstaked": 0,
    "vdfRevelationRewardsLiquid": 0,
    "vdfRevelationRewardsStakedOwn": 0,
    "vdfRevelationRewardsStakedShared": 0,
    "nonceRevelationRewardsLiquid": 0,
    "nonceRevelationRewardsStakedOwn": 0,
    "nonceRevelationRewardsStakedShared": 0,
    "nonceRevelationLosses": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "revelationRewards": 0,
    "revelationLosses": 0,
    "doublePreendorsingLosses": 0,
    "doubleEndorsingLosses": 0,
    "doubleBakingLosses": 0,
    "endorsementRewards": 0,
    "blockRewards": 0,
    "stakingBalance": 0,
    "activeStake": 0,
    "selectedStake": 0,
    "delegatedBalance": 0,
    "numDelegators": 0,
    "ownBlocks": 0,
    "extraBlocks": 0,
    "missedOwnBlocks": 0,
    "missedExtraBlocks": 0,
    "uncoveredOwnBlocks": 0,
    "uncoveredExtraBlocks": 0,
    "uncoveredEndorsements": 0,
    "ownBlockRewards": 0,
    "extraBlockRewards": 0,
    "missedOwnBlockRewards": 0,
    "missedExtraBlockRewards": 0,
    "uncoveredOwnBlockRewards": 0,
    "uncoveredExtraBlockRewards": 0,
    "uncoveredEndorsementRewards": 0,
    "ownBlockFees": 0,
    "extraBlockFees": 0,
    "missedOwnBlockFees": 0,
    "missedExtraBlockFees": 0,
    "uncoveredOwnBlockFees": 0,
    "uncoveredExtraBlockFees": 0,
    "doubleBakingLostDeposits": 0,
    "doubleBakingLostRewards": 0,
    "doubleBakingLostFees": 0,
    "doubleEndorsingLostDeposits": 0,
    "doubleEndorsingLostRewards": 0,
    "doubleEndorsingLostFees": 0,
    "revelationLostRewards": 0,
    "revelationLostFees": 0,
    "futureBlockDeposits": 0,
    "blockDeposits": 0,
    "futureEndorsementDeposits": 0,
    "endorsementDeposits": 0
  }
]

Get delegator cycle rewards count

GET

https://xtz-index.nownodes.io/v1/rewards/delegators/{address}/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns total number of cycles where the delegator was delegated to an active baker

Parameters

addressstringrequiredpath

Delegator address

Response

200OK

Get delegator cycle rewards count

curl -X GET 'https://xtz-index.nownodes.io/v1/rewards/delegators/{address}/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/delegators/{address}/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/delegators/{address}/count')
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://xtz-index.nownodes.io/v1/rewards/delegators/{address}/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/delegators/{address}/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/rewards/delegators/{address}/count";
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://xtz-index.nownodes.io/v1/rewards/delegators/{address}/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/rewards/delegators/{address}/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/delegators/{address}/count')
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

Get delegator cycle rewards

GET

https://xtz-index.nownodes.io/v1/rewards/delegators/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of delegator rewards for every cycle, including future cycles.

Parameters

addressstringrequiredpath

Delegator address.

cycleInt32Parameter | nullquery

Filters rewards by cycle.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts cycle rewards by specified field. Supported fields: cycle (default, desc).

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get delegator cycle rewards

curl -X GET 'https://xtz-index.nownodes.io/v1/rewards/delegators/{address}'

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/delegators/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/delegators/{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://xtz-index.nownodes.io/v1/rewards/delegators/{address}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/delegators/{address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/rewards/delegators/{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://xtz-index.nownodes.io/v1/rewards/delegators/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/rewards/delegators/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/delegators/{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

[
  {
    "cycle": 0,
    "delegatedBalance": 0,
    "stakedBalance": 0,
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "bakingPower": 0,
    "totalBakingPower": 0,
    "bakerDelegatedBalance": 0,
    "externalDelegatedBalance": 0,
    "bakerStakedBalance": 0,
    "externalStakedBalance": 0,
    "expectedBlocks": 0,
    "expectedEndorsements": 0,
    "futureBlocks": 0,
    "futureBlockRewards": 0,
    "blocks": 0,
    "blockRewardsLiquid": 0,
    "blockRewardsStakedOwn": 0,
    "blockRewardsStakedShared": 0,
    "missedBlocks": 0,
    "missedBlockRewards": 0,
    "futureEndorsements": 0,
    "futureEndorsementRewards": 0,
    "endorsements": 0,
    "endorsementRewardsLiquid": 0,
    "endorsementRewardsStakedOwn": 0,
    "endorsementRewardsStakedShared": 0,
    "missedEndorsements": 0,
    "missedEndorsementRewards": 0,
    "blockFees": 0,
    "missedBlockFees": 0,
    "doubleBakingRewards": 0,
    "doubleBakingLostStaked": 0,
    "doubleBakingLostUnstaked": 0,
    "doubleBakingLostExternalStaked": 0,
    "doubleBakingLostExternalUnstaked": 0,
    "doubleEndorsingRewards": 0,
    "doubleEndorsingLostStaked": 0,
    "doubleEndorsingLostUnstaked": 0,
    "doubleEndorsingLostExternalStaked": 0,
    "doubleEndorsingLostExternalUnstaked": 0,
    "doublePreendorsingRewards": 0,
    "doublePreendorsingLostStaked": 0,
    "doublePreendorsingLostUnstaked": 0,
    "doublePreendorsingLostExternalStaked": 0,
    "doublePreendorsingLostExternalUnstaked": 0,
    "vdfRevelationRewardsLiquid": 0,
    "vdfRevelationRewardsStakedOwn": 0,
    "vdfRevelationRewardsStakedShared": 0,
    "nonceRevelationRewardsLiquid": 0,
    "nonceRevelationRewardsStakedOwn": 0,
    "nonceRevelationRewardsStakedShared": 0,
    "nonceRevelationLosses": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "revelationRewards": 0,
    "revelationLosses": 0,
    "doublePreendorsingLosses": 0,
    "doubleEndorsingLosses": 0,
    "doubleBakingLosses": 0,
    "endorsementRewards": 0,
    "blockRewards": 0,
    "stakingBalance": 0,
    "activeStake": 0,
    "selectedStake": 0,
    "balance": 0,
    "ownBlocks": 0,
    "extraBlocks": 0,
    "missedOwnBlocks": 0,
    "missedExtraBlocks": 0,
    "uncoveredOwnBlocks": 0,
    "uncoveredExtraBlocks": 0,
    "uncoveredEndorsements": 0,
    "ownBlockRewards": 0,
    "extraBlockRewards": 0,
    "missedOwnBlockRewards": 0,
    "missedExtraBlockRewards": 0,
    "uncoveredOwnBlockRewards": 0,
    "uncoveredExtraBlockRewards": 0,
    "uncoveredEndorsementRewards": 0,
    "ownBlockFees": 0,
    "extraBlockFees": 0,
    "missedOwnBlockFees": 0,
    "missedExtraBlockFees": 0,
    "uncoveredOwnBlockFees": 0,
    "uncoveredExtraBlockFees": 0,
    "doubleBakingLostDeposits": 0,
    "doubleBakingLostRewards": 0,
    "doubleBakingLostFees": 0,
    "doubleEndorsingLostDeposits": 0,
    "doubleEndorsingLostRewards": 0,
    "doubleEndorsingLostFees": 0,
    "revelationLostRewards": 0,
    "revelationLostFees": 0
  }
]

Get reward split

GET

https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns baker rewards for the specified cycle with all delegator balances at that cycle to allow rewards distribution in proportion to shares.

Parameters

bakerstringrequiredpath

Baker address

cycleinteger<int32>requiredpath

Rewards cycle

offsetinteger<int32>0query

Specifies how many delegators in the reward split should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of delegators to return

Response

200OK

Get reward split

curl -X GET 'https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}'

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}')
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://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}";
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://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}')
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

{
  "cycle": 0,
  "bakingPower": 0,
  "totalBakingPower": 0,
  "ownDelegatedBalance": 0,
  "externalDelegatedBalance": 0,
  "delegatorsCount": 0,
  "ownStakedBalance": 0,
  "externalStakedBalance": 0,
  "stakersCount": 0,
  "expectedBlocks": 0,
  "expectedEndorsements": 0,
  "futureBlocks": 0,
  "futureBlockRewards": 0,
  "blocks": 0,
  "blockRewardsLiquid": 0,
  "blockRewardsStakedOwn": 0,
  "blockRewardsStakedShared": 0,
  "missedBlocks": 0,
  "missedBlockRewards": 0,
  "futureEndorsements": 0,
  "futureEndorsementRewards": 0,
  "endorsements": 0,
  "endorsementRewardsLiquid": 0,
  "endorsementRewardsStakedOwn": 0,
  "endorsementRewardsStakedShared": 0,
  "missedEndorsements": 0,
  "missedEndorsementRewards": 0,
  "blockFees": 0,
  "missedBlockFees": 0,
  "doubleBakingRewards": 0,
  "doubleBakingLostStaked": 0,
  "doubleBakingLostUnstaked": 0,
  "doubleBakingLostExternalStaked": 0,
  "doubleBakingLostExternalUnstaked": 0,
  "doubleEndorsingRewards": 0,
  "doubleEndorsingLostStaked": 0,
  "doubleEndorsingLostUnstaked": 0,
  "doubleEndorsingLostExternalStaked": 0,
  "doubleEndorsingLostExternalUnstaked": 0,
  "doublePreendorsingRewards": 0,
  "doublePreendorsingLostStaked": 0,
  "doublePreendorsingLostUnstaked": 0,
  "doublePreendorsingLostExternalStaked": 0,
  "doublePreendorsingLostExternalUnstaked": 0,
  "vdfRevelationRewardsLiquid": 0,
  "vdfRevelationRewardsStakedOwn": 0,
  "vdfRevelationRewardsStakedShared": 0,
  "nonceRevelationRewardsLiquid": 0,
  "nonceRevelationRewardsStakedOwn": 0,
  "nonceRevelationRewardsStakedShared": 0,
  "nonceRevelationLosses": 0,
  "delegators": [
    {
      "address": "string",
      "delegatedBalance": 0,
      "stakedBalance": 0,
      "currentDelegatedBalance": 0,
      "currentStakedBalance": 0,
      "emptied": true,
      "balance": 0,
      "currentBalance": 0
    }
  ],
  "revelationRewards": 0,
  "revelationLosses": 0,
  "doublePreendorsingLosses": 0,
  "doubleEndorsingLosses": 0,
  "doubleBakingLosses": 0,
  "endorsementRewards": 0,
  "blockRewards": 0,
  "stakingBalance": 0,
  "activeStake": 0,
  "selectedStake": 0,
  "delegatedBalance": 0,
  "numDelegators": 0,
  "ownBlocks": 0,
  "extraBlocks": 0,
  "missedOwnBlocks": 0,
  "missedExtraBlocks": 0,
  "uncoveredOwnBlocks": 0,
  "uncoveredExtraBlocks": 0,
  "uncoveredEndorsements": 0,
  "ownBlockRewards": 0,
  "extraBlockRewards": 0,
  "missedOwnBlockRewards": 0,
  "missedExtraBlockRewards": 0,
  "uncoveredOwnBlockRewards": 0,
  "uncoveredExtraBlockRewards": 0,
  "uncoveredEndorsementRewards": 0,
  "ownBlockFees": 0,
  "extraBlockFees": 0,
  "missedOwnBlockFees": 0,
  "missedExtraBlockFees": 0,
  "uncoveredOwnBlockFees": 0,
  "uncoveredExtraBlockFees": 0,
  "doubleBakingLostDeposits": 0,
  "doubleBakingLostRewards": 0,
  "doubleBakingLostFees": 0,
  "doubleEndorsingLostDeposits": 0,
  "doubleEndorsingLostRewards": 0,
  "doubleEndorsingLostFees": 0,
  "revelationLostRewards": 0,
  "revelationLostFees": 0,
  "futureBlockDeposits": 0,
  "blockDeposits": 0,
  "futureEndorsementDeposits": 0,
  "endorsementDeposits": 0
}

Get reward split delegator

GET

https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}/{delegator}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns delegator from the reward split for the specified cycle.

Parameters

bakerstringrequiredpath

Baker address

cycleinteger<int32>requiredpath

Reward split cycle

delegatorstringrequiredpath

Delegator address

Response

200OK

Get reward split delegator

curl -X GET 'https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}/{delegator}'

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}/{delegator}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}/{delegator}')
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://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}/{delegator}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}/{delegator}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}/{delegator}";
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://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}/{delegator}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}/{delegator}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rewards/split/{baker}/{cycle}/{delegator}')
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": "string",
  "delegatedBalance": 0,
  "stakedBalance": 0,
  "currentDelegatedBalance": 0,
  "currentStakedBalance": 0,
  "emptied": true,
  "balance": 0,
  "currentBalance": 0
}

Rights

Get rights count

GET

https://xtz-index.nownodes.io/v1/rights/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of stored rights.

Parameters

typeBakingRightTypeParameter | nullquery

Filters rights by type (baking, endorsing)

bakerAccountParameter | nullquery

Filters rights by baker

cycleInt32Parameter | nullquery

Filters rights by cycle

levelInt32Parameter | nullquery

Filters rights by level

slotsInt32NullParameter | nullquery

Filters rights by slots

roundInt32NullParameter | nullquery

Filters rights by round

priorityInt32NullParameter | nullquery

[DEPRECATED]

statusBakingRightStatusParameter | nullquery

Filters rights by status (future, realized, missed)

Response

200OK

Get rights count

curl -X GET 'https://xtz-index.nownodes.io/v1/rights/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/rights/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rights/count')
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://xtz-index.nownodes.io/v1/rights/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/rights/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/rights/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rights/count')
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

Get rights

GET

https://xtz-index.nownodes.io/v1/rights

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of rights.

Parameters

typeBakingRightTypeParameter | nullquery

Filters rights by type (baking, endorsing)

bakerAccountParameter | nullquery

Filters rights by baker

cycleInt32Parameter | nullquery

Filters rights by cycle

levelInt32Parameter | nullquery

Filters rights by level

slotsInt32NullParameter | nullquery

Filters rights by slots

roundInt32NullParameter | nullquery

Filters rights by round

priorityInt32NullParameter | nullquery

[DEPRECATED]

statusBakingRightStatusParameter | nullquery

Filters rights by status (future, realized, missed)

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts rights by specified field. Supported fields: level (default).

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get rights

curl -X GET 'https://xtz-index.nownodes.io/v1/rights'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/rights')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/rights')
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

[
  {
    "type": "string",
    "cycle": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "round": 0,
    "slots": 0,
    "baker": {
      "alias": "string",
      "address": "string"
    },
    "status": "string",
    "priority": 0
  }
]

SmartRollups

Get smart rollups count

GET

https://xtz-index.nownodes.io/v1/smart_rollups/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of smart rollups.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

addressAddressParameter | nullquery

Filter by smart rollup address.
Click on the parameter to expand more details.

creatorAccountParameter | nullquery

Filter by smart rollup creator.
Click on the parameter to expand more details.

firstActivityInt32Parameter | nullquery

Filter by level of the block, where the rollup was first seen.
Click on the parameter to expand more details.

firstActivityTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the rollup was first seen.
Click on the parameter to expand more details.

lastActivityInt32Parameter | nullquery

Filter by level of the block, where the rollup was last seen.
Click on the parameter to expand more details.

lastActivityTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the rollup was last seen.
Click on the parameter to expand more details.

Response

200OK

Get smart rollups count

curl -X GET 'https://xtz-index.nownodes.io/v1/smart_rollups/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/count')
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://xtz-index.nownodes.io/v1/smart_rollups/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/smart_rollups/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/count')
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

Get smart rollups

GET

https://xtz-index.nownodes.io/v1/smart_rollups

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollups.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

addressAddressParameter | nullquery

Filter by smart rollup address.
Click on the parameter to expand more details.

creatorAccountParameter | nullquery

Filter by smart rollup creator.
Click on the parameter to expand more details.

firstActivityInt32Parameter | nullquery

Filter by level of the block, where the rollup was first seen.
Click on the parameter to expand more details.

firstActivityTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the rollup was first seen.
Click on the parameter to expand more details.

lastActivityInt32Parameter | nullquery

Filter by level of the block, where the rollup was last seen.
Click on the parameter to expand more details.

lastActivityTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the rollup was last seen.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get smart rollups

curl -X GET 'https://xtz-index.nownodes.io/v1/smart_rollups'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/smart_rollups')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups')
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

[
  {
    "type": "string",
    "id": 0,
    "address": "string",
    "alias": "string",
    "creator": {
      "alias": "string",
      "address": "string"
    },
    "pvmKind": "string",
    "genesisCommitment": "string",
    "lastCommitment": "string",
    "inboxLevel": 0,
    "totalStakers": 0,
    "activeStakers": 0,
    "executedCommitments": 0,
    "cementedCommitments": 0,
    "pendingCommitments": 0,
    "refutedCommitments": 0,
    "orphanCommitments": 0,
    "smartRollupBonds": 0,
    "activeTokensCount": 0,
    "tokenBalancesCount": 0,
    "tokenTransfersCount": 0,
    "activeTicketsCount": 0,
    "ticketBalancesCount": 0,
    "ticketTransfersCount": 0,
    "numTransactions": 0,
    "transferTicketCount": 0,
    "smartRollupCementCount": 0,
    "smartRollupExecuteCount": 0,
    "smartRollupOriginateCount": 0,
    "smartRollupPublishCount": 0,
    "smartRollupRecoverBondCount": 0,
    "smartRollupRefuteCount": 0,
    "refutationGamesCount": 0,
    "activeRefutationGamesCount": 0,
    "firstActivity": 0,
    "firstActivityTime": "2024-01-15T09:30:00Z",
    "lastActivity": 0,
    "lastActivityTime": "2024-01-15T09:30:00Z"
  }
]

Get smart rollup by address

GET

https://xtz-index.nownodes.io/v1/smart_rollups/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a smart rollup with the specified address.

Parameters

addressstringrequiredpath

Smart rollup address

Response

200OK

Get smart rollup by address

curl -X GET 'https://xtz-index.nownodes.io/v1/smart_rollups/{address}'

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/{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://xtz-index.nownodes.io/v1/smart_rollups/{address}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/{address}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/smart_rollups/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/{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

{
  "type": "string",
  "id": 0,
  "address": "string",
  "alias": "string",
  "creator": {
    "alias": "string",
    "address": "string"
  },
  "pvmKind": "string",
  "genesisCommitment": "string",
  "lastCommitment": "string",
  "inboxLevel": 0,
  "totalStakers": 0,
  "activeStakers": 0,
  "executedCommitments": 0,
  "cementedCommitments": 0,
  "pendingCommitments": 0,
  "refutedCommitments": 0,
  "orphanCommitments": 0,
  "smartRollupBonds": 0,
  "activeTokensCount": 0,
  "tokenBalancesCount": 0,
  "tokenTransfersCount": 0,
  "activeTicketsCount": 0,
  "ticketBalancesCount": 0,
  "ticketTransfersCount": 0,
  "numTransactions": 0,
  "transferTicketCount": 0,
  "smartRollupCementCount": 0,
  "smartRollupExecuteCount": 0,
  "smartRollupOriginateCount": 0,
  "smartRollupPublishCount": 0,
  "smartRollupRecoverBondCount": 0,
  "smartRollupRefuteCount": 0,
  "refutationGamesCount": 0,
  "activeRefutationGamesCount": 0,
  "firstActivity": 0,
  "firstActivityTime": "2024-01-15T09:30:00Z",
  "lastActivity": 0,
  "lastActivityTime": "2024-01-15T09:30:00Z"
}

Get JSON Schema [2020-12] interface for the smart rollup

GET

https://xtz-index.nownodes.io/v1/smart_rollups/{address}/interface

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns standard JSON Schema for smart rollup parameter.

Parameters

addressstringrequiredpath

Smart rollup address

Response

200OK

Get JSON Schema [2020-12] interface for the smart rollup

curl -X GET 'https://xtz-index.nownodes.io/v1/smart_rollups/{address}/interface'

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/{address}/interface', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/{address}/interface')
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://xtz-index.nownodes.io/v1/smart_rollups/{address}/interface')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/{address}/interface', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/smart_rollups/{address}/interface";
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://xtz-index.nownodes.io/v1/smart_rollups/{address}/interface', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/smart_rollups/{address}/interface')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/{address}/interface')
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

{
  "entrypoints": [
    {
      "name": "string"
    }
  ],
  "bigMaps": [
    {
      "path": "string",
      "name": "string"
    }
  ],
  "events": [
    {
      "tag": "string"
    }
  ]
}

Get smart rollup stakers

GET

https://xtz-index.nownodes.io/v1/smart_rollups/{address}/stakers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollup stakers.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

addressAddressParameterrequiredpath

Filter by smart rollup staker address.
Click on the parameter to expand more details.

bondStatusSrBondStatusParameter | nullquery

Filter by staker bond status (active, returned, or lost).
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get smart rollup stakers

curl -X GET 'https://xtz-index.nownodes.io/v1/smart_rollups/{address}/stakers'

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/{address}/stakers', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/{address}/stakers')
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://xtz-index.nownodes.io/v1/smart_rollups/{address}/stakers')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/{address}/stakers', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/smart_rollups/{address}/stakers";
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://xtz-index.nownodes.io/v1/smart_rollups/{address}/stakers', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/smart_rollups/{address}/stakers')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/{address}/stakers')
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

[
  {
    "alias": "string",
    "address": "string",
    "id": 0,
    "bondStatus": "string",
    "bondLevel": 0,
    "bondTime": "2024-01-15T09:30:00Z"
  }
]

Get smart rollup commitments count

GET

https://xtz-index.nownodes.io/v1/smart_rollups/commitments/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of smart rollup commitments.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

initiatorAccountParameter | nullquery

Filter by initiator (an account published the commitment first).
Click on the parameter to expand more details.

rollupAccountParameter | nullquery

Filter by smart rollup.
Click on the parameter to expand more details.

inboxLevelInt32Parameter | nullquery

Filter by inbox level.
Click on the parameter to expand more details.

hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block, where the commitment was first seen.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the commitment was first seen.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block, where the commitment was last seen.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the commitment was last seen.
Click on the parameter to expand more details.

statusSrCommitmentStatusParameter | nullquery

Filter by commitment status (pending, cemented, executed, refuted, or orphan).
Click on the parameter to expand more details.

predecessor.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

predecessor.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

Response

200OK

Get smart rollup commitments count

curl -X GET 'https://xtz-index.nownodes.io/v1/smart_rollups/commitments/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/commitments/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/commitments/count')
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://xtz-index.nownodes.io/v1/smart_rollups/commitments/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/commitments/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/smart_rollups/commitments/count";
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://xtz-index.nownodes.io/v1/smart_rollups/commitments/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/smart_rollups/commitments/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/commitments/count')
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

Get smart rollup commitments

GET

https://xtz-index.nownodes.io/v1/smart_rollups/commitments

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollup commitments.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

initiatorAccountParameter | nullquery

Filter by initiator (an account published the commitment first).
Click on the parameter to expand more details.

rollupAccountParameter | nullquery

Filter by smart rollup.
Click on the parameter to expand more details.

inboxLevelInt32Parameter | nullquery

Filter by inbox level.
Click on the parameter to expand more details.

hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block, where the commitment was first seen.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the commitment was first seen.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block, where the commitment was last seen.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the commitment was last seen.
Click on the parameter to expand more details.

statusSrCommitmentStatusParameter | nullquery

Filter by commitment status (pending, cemented, executed, refuted, or orphan).
Click on the parameter to expand more details.

predecessor.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

predecessor.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get smart rollup commitments

curl -X GET 'https://xtz-index.nownodes.io/v1/smart_rollups/commitments'

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/commitments', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/commitments')
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://xtz-index.nownodes.io/v1/smart_rollups/commitments')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/commitments', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/smart_rollups/commitments')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/commitments')
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": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "inboxLevel": 0,
    "state": "string",
    "hash": "string",
    "ticks": 0,
    "firstLevel": 0,
    "firstTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "lastTime": "2024-01-15T09:30:00Z",
    "stakers": 0,
    "activeStakers": 0,
    "successors": 0,
    "status": "string",
    "predecessor": {
      "id": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "inboxLevel": 0,
      "state": "string",
      "hash": "string",
      "ticks": 0,
      "firstLevel": 0,
      "firstTime": "2024-01-15T09:30:00Z"
    }
  }
]

Get smart rollup games count

GET

https://xtz-index.nownodes.io/v1/smart_rollups/games/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of smart rollup refutation games.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

rollupAccountParameter | nullquery

Filter by smart rollup.
Click on the parameter to expand more details.

initiatorAccountParameter | nullquery

Filter by initiator (who found a wrong commitment and started the refutation game).
Click on the parameter to expand more details.

initiatorCommitment.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

initiatorCommitment.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

opponentAccountParameter | nullquery

Filter by opponent (who was accused in publishing a wrong commitment).
Click on the parameter to expand more details.

opponentCommitment.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

opponentCommitment.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block, where the refutation game was started.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the refutation game was started.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block, where the refutation game was last updated.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the refutation game was last updated.
Click on the parameter to expand more details.

Response

200OK

Get smart rollup games count

curl -X GET 'https://xtz-index.nownodes.io/v1/smart_rollups/games/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/games/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/games/count')
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://xtz-index.nownodes.io/v1/smart_rollups/games/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/games/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/smart_rollups/games/count";
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://xtz-index.nownodes.io/v1/smart_rollups/games/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/smart_rollups/games/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/games/count')
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

Get smart rollup games

GET

https://xtz-index.nownodes.io/v1/smart_rollups/games

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollup refutation games.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

rollupAccountParameter | nullquery

Filter by smart rollup.
Click on the parameter to expand more details.

initiatorAccountParameter | nullquery

Filter by initiator (who found a wrong commitment and started the refutation game).
Click on the parameter to expand more details.

initiatorCommitment.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

initiatorCommitment.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

opponentAccountParameter | nullquery

Filter by opponent (who was accused in publishing a wrong commitment).
Click on the parameter to expand more details.

opponentCommitment.idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

opponentCommitment.hashSrc1HashParameter | nullquery

Filter by commitment hash.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block, where the refutation game was started.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the refutation game was started.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block, where the refutation game was last updated.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp of the block, where the refutation game was last updated.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get smart rollup games

curl -X GET 'https://xtz-index.nownodes.io/v1/smart_rollups/games'

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/games', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/games')
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://xtz-index.nownodes.io/v1/smart_rollups/games')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/games', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/smart_rollups/games')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/games')
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": 0,
    "rollup": {
      "alias": "string",
      "address": "string"
    },
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "initiatorCommitment": {
      "id": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "inboxLevel": 0,
      "state": "string",
      "hash": "string",
      "ticks": 0,
      "firstLevel": 0,
      "firstTime": "2024-01-15T09:30:00Z"
    },
    "opponent": {
      "alias": "string",
      "address": "string"
    },
    "opponentCommitment": {
      "id": 0,
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "inboxLevel": 0,
      "state": "string",
      "hash": "string",
      "ticks": 0,
      "firstLevel": 0,
      "firstTime": "2024-01-15T09:30:00Z"
    },
    "lastMove": {
      "id": 0,
      "level": 0,
      "timestamp": "2024-01-15T09:30:00Z",
      "sender": {
        "alias": "string",
        "address": "string"
      },
      "move": "string",
      "gameStatus": "string"
    },
    "firstLevel": 0,
    "firstTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "lastTime": "2024-01-15T09:30:00Z",
    "initiatorReward": 0,
    "initiatorLoss": 0,
    "opponentReward": 0,
    "opponentLoss": 0
  }
]

Get inbox messages count

GET

https://xtz-index.nownodes.io/v1/smart_rollups/inbox/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of smart rollup inbox messages.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by level of the block, where the message was pushed.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp of the block, where the message was pushed.
Click on the parameter to expand more details.

typeSrMessageTypeParameter | nullquery

Filter by inbox message type (level_start, level_info, level_end, transfer, external, migration).
Click on the parameter to expand more details.

Response

200OK

Get inbox messages count

curl -X GET 'https://xtz-index.nownodes.io/v1/smart_rollups/inbox/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/inbox/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/inbox/count')
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://xtz-index.nownodes.io/v1/smart_rollups/inbox/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/inbox/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/smart_rollups/inbox/count";
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://xtz-index.nownodes.io/v1/smart_rollups/inbox/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/smart_rollups/inbox/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/inbox/count')
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

Get inbox messages

GET

https://xtz-index.nownodes.io/v1/smart_rollups/inbox

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of smart rollup inbox messages.

Parameters

idInt32Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by level of the block, where the message was pushed.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp of the block, where the message was pushed.
Click on the parameter to expand more details.

typeSrMessageTypeParameter | nullquery

Filter by inbox message type (level_start, level_info, level_end, transfer, external, migration).
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

michelineMichelineFormatJsonquery

Format of smart rollup call parameters: 0 - JSON, 1 - JSON string, 2 - raw micheline, 3 - raw micheline string

Response

200OK

Get inbox messages

curl -X GET 'https://xtz-index.nownodes.io/v1/smart_rollups/inbox'

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/inbox', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/inbox')
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://xtz-index.nownodes.io/v1/smart_rollups/inbox')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/smart_rollups/inbox', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/smart_rollups/inbox')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/smart_rollups/inbox')
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": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "type": "string",
    "predecessorHash": "string",
    "predecessorTimestamp": "2024-01-15T09:30:00Z",
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "sender": {
      "alias": "string",
      "address": "string"
    },
    "target": {
      "alias": "string",
      "address": "string"
    },
    "entrypoint": "string",
    "payload": "dGVzdA==",
    "protocol": "string"
  }
]

Software

Get baker software

GET

https://xtz-index.nownodes.io/v1/software

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of baker software.

Parameters

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts delegators by specified field. Supported fields: id (default), firstLevel, lastLevel, blocksCount.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get baker software

curl -X GET 'https://xtz-index.nownodes.io/v1/software'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/software')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/software')
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

[
  {
    "shortHash": "string",
    "firstLevel": 0,
    "firstTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "lastTime": "2024-01-15T09:30:00Z",
    "blocksCount": 0
  }
]

Get software count

GET

https://xtz-index.nownodes.io/v1/software/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a number of software.

Response

200OK

Get software count

curl -X GET 'https://xtz-index.nownodes.io/v1/software/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/software/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/software/count')
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://xtz-index.nownodes.io/v1/software/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/software/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/software/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/software/count')
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

Statistics

Get statistics

GET

https://xtz-index.nownodes.io/v1/statistics

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of end-of-block statistics.

Parameters

levelInt32Parameter | nullquery

Filters statistics by level.

timestampTimestampParameter | nullquery

Filters statistics by timestamp.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts delegators by specified field. Supported fields: id (default), level, cycle, date.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get statistics

curl -X GET 'https://xtz-index.nownodes.io/v1/statistics'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/statistics')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/statistics')
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

[
  {
    "cycle": 0,
    "date": "2024-01-15T09:30:00Z",
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "totalSupply": 0,
    "circulatingSupply": 0,
    "totalBootstrapped": 0,
    "totalCommitments": 0,
    "totalActivated": 0,
    "totalCreated": 0,
    "totalBurned": 0,
    "totalBanished": 0,
    "totalFrozen": 0,
    "totalRollupBonds": 0,
    "totalSmartRollupBonds": 0,
    "totalLost": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "totalVested": 0
  }
]

Get daily statistics

GET

https://xtz-index.nownodes.io/v1/statistics/daily

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of end-of-day statistics.

Parameters

dateDateTimeParameter | nullquery

Filters statistics by date.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts delegators by specified field. Supported fields: id (default), level, cycle, date.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get daily statistics

curl -X GET 'https://xtz-index.nownodes.io/v1/statistics/daily'

const response = await fetch('https://xtz-index.nownodes.io/v1/statistics/daily', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/statistics/daily')
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://xtz-index.nownodes.io/v1/statistics/daily')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/statistics/daily', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/statistics/daily')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/statistics/daily')
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

[
  {
    "cycle": 0,
    "date": "2024-01-15T09:30:00Z",
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "totalSupply": 0,
    "circulatingSupply": 0,
    "totalBootstrapped": 0,
    "totalCommitments": 0,
    "totalActivated": 0,
    "totalCreated": 0,
    "totalBurned": 0,
    "totalBanished": 0,
    "totalFrozen": 0,
    "totalRollupBonds": 0,
    "totalSmartRollupBonds": 0,
    "totalLost": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "totalVested": 0
  }
]

Get cyclic statistics

GET

https://xtz-index.nownodes.io/v1/statistics/cyclic

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of end-of-cycle statistics.

Parameters

cycleInt32Parameter | nullquery

Filters statistics by cycle.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts delegators by specified field. Supported fields: id (default), level, cycle, date.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get cyclic statistics

curl -X GET 'https://xtz-index.nownodes.io/v1/statistics/cyclic'

const response = await fetch('https://xtz-index.nownodes.io/v1/statistics/cyclic', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/statistics/cyclic')
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://xtz-index.nownodes.io/v1/statistics/cyclic')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/statistics/cyclic', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/statistics/cyclic')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/statistics/cyclic')
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

[
  {
    "cycle": 0,
    "date": "2024-01-15T09:30:00Z",
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "totalSupply": 0,
    "circulatingSupply": 0,
    "totalBootstrapped": 0,
    "totalCommitments": 0,
    "totalActivated": 0,
    "totalCreated": 0,
    "totalBurned": 0,
    "totalBanished": 0,
    "totalFrozen": 0,
    "totalRollupBonds": 0,
    "totalSmartRollupBonds": 0,
    "totalLost": 0,
    "quote": {
      "btc": 0,
      "eur": 0,
      "usd": 0,
      "cny": 0,
      "jpy": 0,
      "krw": 0,
      "eth": 0,
      "gbp": 0
    },
    "totalVested": 0
  }
]

Get current statistics

GET

https://xtz-index.nownodes.io/v1/statistics/current

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns statistics at the end of a head block.

Parameters

selectSelectParameter | nullquery

quoteSymbolsNonequery

Comma-separated list of ticker symbols to inject historical prices into response

Response

200OK

Get current statistics

curl -X GET 'https://xtz-index.nownodes.io/v1/statistics/current'

const response = await fetch('https://xtz-index.nownodes.io/v1/statistics/current', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/statistics/current')
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://xtz-index.nownodes.io/v1/statistics/current')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/statistics/current', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/statistics/current')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/statistics/current')
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

{
  "cycle": 0,
  "date": "2024-01-15T09:30:00Z",
  "level": 0,
  "timestamp": "2024-01-15T09:30:00Z",
  "totalSupply": 0,
  "circulatingSupply": 0,
  "totalBootstrapped": 0,
  "totalCommitments": 0,
  "totalActivated": 0,
  "totalCreated": 0,
  "totalBurned": 0,
  "totalBanished": 0,
  "totalFrozen": 0,
  "totalRollupBonds": 0,
  "totalSmartRollupBonds": 0,
  "totalLost": 0,
  "quote": {
    "btc": 0,
    "eur": 0,
    "usd": 0,
    "cny": 0,
    "jpy": 0,
    "krw": 0,
    "eth": 0,
    "gbp": 0
  },
  "totalVested": 0
}

Tickets

Get tickets count

GET

https://xtz-index.nownodes.io/v1/tickets/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of tickets.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

ticketerAccountParameter | nullquery

Filter by ticketer address.
Click on the parameter to expand more details.

rawTypeMichelineParameter | nullquery

Filter by ticket content type in Micheline format.
Click on the parameter to expand more details.

rawContentMichelineParameter | nullquery

Filter by ticket content in Micheline format.
Click on the parameter to expand more details.

contentJsonParameter | nullquery

Filter by ticket content in JSON format.
Note, this parameter supports the following format: content{.path?}{.mode?}=..., so you can specify a path to a particular field to filter by (for example, ?content.color.in=red,green).
Click on the parameter to expand more details.

typeHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content type.
Click on the parameter to expand more details.

contentHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content.
Click on the parameter to expand more details.

firstMinterAccountParameter | nullquery

Filter by address of the first minter.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block where the ticket was first seen.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the ticket was first seen.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block where the ticket was last seen.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the ticket was last seen.
Click on the parameter to expand more details.

Response

200OK

Get tickets count

curl -X GET 'https://xtz-index.nownodes.io/v1/tickets/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/tickets/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tickets/count')
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://xtz-index.nownodes.io/v1/tickets/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/tickets/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tickets/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tickets/count')
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

Get tickets

GET

https://xtz-index.nownodes.io/v1/tickets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of tickets.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

ticketerAccountParameter | nullquery

Filter by ticketer address.
Click on the parameter to expand more details.

rawTypeMichelineParameter | nullquery

Filter by ticket content type in Micheline format.
Click on the parameter to expand more details.

rawContentMichelineParameter | nullquery

Filter by ticket content in Micheline format.
Click on the parameter to expand more details.

contentJsonParameter | nullquery

typeHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content type.
Click on the parameter to expand more details.

contentHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content.
Click on the parameter to expand more details.

firstMinterAccountParameter | nullquery

Filter by address of the first minter.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block where the ticket was first seen.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the ticket was first seen.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block where the ticket was last seen.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the ticket was last seen.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get tickets

curl -X GET 'https://xtz-index.nownodes.io/v1/tickets'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tickets')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tickets')
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": 0,
    "ticketer": {
      "alias": "string",
      "address": "string"
    },
    "rawType": {
      "type": 0
    },
    "rawContent": {
      "type": 0
    },
    "typeHash": 0,
    "contentHash": 0,
    "firstMinter": {
      "alias": "string",
      "address": "string"
    },
    "firstLevel": 0,
    "firstTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "lastTime": "2024-01-15T09:30:00Z",
    "transfersCount": 0,
    "balancesCount": 0,
    "holdersCount": 0,
    "totalMinted": "string",
    "totalBurned": "string",
    "totalSupply": "string"
  }
]

Get ticket balances count

GET

https://xtz-index.nownodes.io/v1/tickets/balances/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of ticket balances.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

ticket.idInt64Parameter | nullquery

Filter by internal TzKT id. Click on the parameter to expand more details.

ticket.ticketerAccountParameter | nullquery

Filter by ticketer address.
Click on the parameter to expand more details.

ticket.rawTypeMichelineParameter | nullquery

Filter by ticket content type in Micheline format.
Click on the parameter to expand more details.

ticket.rawContentMichelineParameter | nullquery

Filter by ticket content in Micheline format.
Click on the parameter to expand more details.

ticket.contentJsonParameter | nullquery

ticket.typeHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content type.
Click on the parameter to expand more details.

ticket.contentHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content.
Click on the parameter to expand more details.

accountAccountParameter | nullquery

Filter by account address.
Click on the parameter to expand more details.

balanceNatParameter | nullquery

Filter by balance.
Click on the parameter to expand more details.

transfersCountInt32Parameter | nullquery

Filter by number of transfers.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block where the balance was first changed.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the balance was first changed.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block where the balance was last changed.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the balance was last changed.
Click on the parameter to expand more details.

Response

200OK

Get ticket balances count

curl -X GET 'https://xtz-index.nownodes.io/v1/tickets/balances/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/tickets/balances/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tickets/balances/count')
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://xtz-index.nownodes.io/v1/tickets/balances/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/tickets/balances/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tickets/balances/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tickets/balances/count')
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

Get ticket balances

GET

https://xtz-index.nownodes.io/v1/tickets/balances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of ticket balances.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

ticket.idInt64Parameter | nullquery

Filter by internal TzKT id. Click on the parameter to expand more details.

ticket.ticketerAccountParameter | nullquery

Filter by ticketer address.
Click on the parameter to expand more details.

ticket.rawTypeMichelineParameter | nullquery

Filter by ticket content type in Micheline format.
Click on the parameter to expand more details.

ticket.rawContentMichelineParameter | nullquery

Filter by ticket content in Micheline format.
Click on the parameter to expand more details.

ticket.contentJsonParameter | nullquery

ticket.typeHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content type.
Click on the parameter to expand more details.

ticket.contentHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content.
Click on the parameter to expand more details.

accountAccountParameter | nullquery

Filter by account address.
Click on the parameter to expand more details.

balanceNatParameter | nullquery

Filter by balance.
Click on the parameter to expand more details.

transfersCountInt32Parameter | nullquery

Filter by number of transfers.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block where the balance was first changed.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the balance was first changed.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block where the balance was last changed.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the balance was last changed.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get ticket balances

curl -X GET 'https://xtz-index.nownodes.io/v1/tickets/balances'

const response = await fetch('https://xtz-index.nownodes.io/v1/tickets/balances', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tickets/balances')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tickets/balances')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/tickets/balances', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/tickets/balances";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz-index.nownodes.io/v1/tickets/balances', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tickets/balances')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tickets/balances')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "id": 0,
    "ticket": {
      "id": 0,
      "ticketer": {
        "alias": "string",
        "address": "string"
      },
      "rawType": {
        "type": 0
      },
      "rawContent": {
        "type": 0
      },
      "typeHash": 0,
      "contentHash": 0,
      "totalSupply": "string"
    },
    "account": {
      "alias": "string",
      "address": "string"
    },
    "balance": "string",
    "transfersCount": 0,
    "firstLevel": 0,
    "firstTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "lastTime": "2024-01-15T09:30:00Z"
  }
]

Get ticket transfers count

GET

https://xtz-index.nownodes.io/v1/tickets/transfers/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of ticket transfers.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by level of the block where the transfer was made.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the transfer was made.
Click on the parameter to expand more details.

ticket.idInt64Parameter | nullquery

Filter by internal TzKT id. Click on the parameter to expand more details.

ticket.ticketerAccountParameter | nullquery

Filter by ticketer address.
Click on the parameter to expand more details.

ticket.rawTypeMichelineParameter | nullquery

Filter by ticket content type in Micheline format.
Click on the parameter to expand more details.

ticket.rawContentMichelineParameter | nullquery

Filter by ticket content in Micheline format.
Click on the parameter to expand more details.

ticket.contentJsonParameter | nullquery

ticket.typeHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content type.
Click on the parameter to expand more details.

ticket.contentHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content.
Click on the parameter to expand more details.

anyofAnyOfParameter | nullquery

Filter by any of the specified fields (from or to). Example: anyof.from.to=tz1... will return transfers where from OR to is equal to the specified value. This parameter is useful when you need to get both incoming and outgoing transfers of the account at once.
Click on the parameter to expand more details.

fromAccountParameter | nullquery

Filter by sender address.
Click on the parameter to expand more details.

toAccountParameter | nullquery

Filter by recepient address.
Click on the parameter to expand more details.

amountNatParameter | nullquery

Filter by amount.
Click on the parameter to expand more details.

transactionIdInt64NullParameter | nullquery

Filter by id of the transaction, caused the ticket transfer.
Click on the parameter to expand more details.

transferTicketIdInt64NullParameter | nullquery

Filter by id of the transfer_ticket operation, caused the ticket transfer.
Click on the parameter to expand more details.

smartRollupExecuteIdInt64NullParameter | nullquery

Filter by id of the smart_rollup_execute operation, caused the ticket transfer.
Click on the parameter to expand more details.

Response

200OK

Get ticket transfers count

curl -X GET 'https://xtz-index.nownodes.io/v1/tickets/transfers/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/tickets/transfers/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tickets/transfers/count')
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://xtz-index.nownodes.io/v1/tickets/transfers/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/tickets/transfers/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tickets/transfers/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tickets/transfers/count')
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

Get ticket transfers

GET

https://xtz-index.nownodes.io/v1/tickets/transfers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of ticket transfers.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by level of the block where the transfer was made.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the transfer was made.
Click on the parameter to expand more details.

ticket.idInt64Parameter | nullquery

Filter by internal TzKT id. Click on the parameter to expand more details.

ticket.ticketerAccountParameter | nullquery

Filter by ticketer address.
Click on the parameter to expand more details.

ticket.rawTypeMichelineParameter | nullquery

Filter by ticket content type in Micheline format.
Click on the parameter to expand more details.

ticket.rawContentMichelineParameter | nullquery

Filter by ticket content in Micheline format.
Click on the parameter to expand more details.

ticket.contentJsonParameter | nullquery

ticket.typeHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content type.
Click on the parameter to expand more details.

ticket.contentHashInt32Parameter | nullquery

Filter by 32-bit hash of ticket content.
Click on the parameter to expand more details.

anyofAnyOfParameter | nullquery

fromAccountParameter | nullquery

Filter by sender address.
Click on the parameter to expand more details.

toAccountParameter | nullquery

Filter by recepient address.
Click on the parameter to expand more details.

amountNatParameter | nullquery

Filter by amount.
Click on the parameter to expand more details.

transactionIdInt64NullParameter | nullquery

Filter by id of the transaction, caused the ticket transfer.
Click on the parameter to expand more details.

transferTicketIdInt64NullParameter | nullquery

Filter by id of the transfer_ticket operation, caused the ticket transfer.
Click on the parameter to expand more details.

smartRollupExecuteIdInt64NullParameter | nullquery

Filter by id of the smart_rollup_execute operation, caused the ticket transfer.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get ticket transfers

curl -X GET 'https://xtz-index.nownodes.io/v1/tickets/transfers'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tickets/transfers')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/tickets/transfers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tickets/transfers')
data = response.json()

require 'net/http'
require 'json'

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

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

200

[
  {
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "ticket": {
      "id": 0,
      "ticketer": {
        "alias": "string",
        "address": "string"
      },
      "rawType": {
        "type": 0
      },
      "rawContent": {
        "type": 0
      },
      "typeHash": 0,
      "contentHash": 0,
      "totalSupply": "string"
    },
    "from": {
      "alias": "string",
      "address": "string"
    },
    "to": {
      "alias": "string",
      "address": "string"
    },
    "amount": "string",
    "transactionId": 0,
    "transferTicketId": 0,
    "smartRollupExecuteId": 0
  }
]

Get historical ticket balances

GET

https://xtz-index.nownodes.io/v1/tickets/historical_balances/{level}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of ticket balances at the end of the specified block. Note, this endpoint is quite heavy, therefore at least one of the filters (account, ticket.id, ticket.ticketer) must be specified.

Parameters

levelinteger<int32>requiredpath

Level of the block at the end of which historical balances must be calculated

idInt64Parameter | nullquery

Filter by internal TzKT id. Click on the parameter to expand more details.

ticket.idInt64Parameter | nullquery

Filter by internal TzKT id. Click on the parameter to expand more details.

ticket.ticketerAccountParameter | nullquery

Filter by ticketer address.
Click on the parameter to expand more details.

accountAccountParameter | nullquery

Filter by account address.
Click on the parameter to expand more details.

balanceNatParameter | nullquery

Filter by balance.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get historical ticket balances

curl -X GET 'https://xtz-index.nownodes.io/v1/tickets/historical_balances/{level}'

const response = await fetch('https://xtz-index.nownodes.io/v1/tickets/historical_balances/{level}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tickets/historical_balances/{level}')
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://xtz-index.nownodes.io/v1/tickets/historical_balances/{level}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/tickets/historical_balances/{level}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/tickets/historical_balances/{level}";
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://xtz-index.nownodes.io/v1/tickets/historical_balances/{level}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tickets/historical_balances/{level}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tickets/historical_balances/{level}')
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": 0,
    "ticket": {
      "id": 0,
      "ticketer": {
        "alias": "string",
        "address": "string"
      },
      "rawType": {
        "type": 0
      },
      "rawContent": {
        "type": 0
      },
      "typeHash": 0,
      "contentHash": 0
    },
    "account": {
      "alias": "string",
      "address": "string"
    },
    "balance": "string"
  }
]

Tokens

Get tokens count

GET

https://xtz-index.nownodes.io/v1/tokens/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of tokens.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id. Note, this is not the same as tokenId nat value.
Click on the parameter to expand more details.

contractAccountParameter | nullquery

Filter by contract address.
Click on the parameter to expand more details.

tokenIdNatParameter | nullquery

Filter by tokenId (for FA1.2 tokens tokenId is always "0").
Click on the parameter to expand more details.

standardTokenStandardParameter | nullquery

Filter by token standard (fa1.2 or fa2).
Click on the parameter to expand more details.

firstMinterAccountParameter | nullquery

Filter by address of the first minter.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block where the token was first seen.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the token was first seen.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block where the token was last seen.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the token was last seen.
Click on the parameter to expand more details.

metadataJsonParameter | nullquery

Filter by metadata.
Note, this parameter supports the following format: metadata{.path?}{.mode?}=..., so you can specify a path to a particular field to filter by (for example, ?metadata.symbol.in=kUSD,uUSD).
Click on the parameter to expand more details.

indexedAtInt32NullParameter | nullquery

Response

200OK

Get tokens count

curl -X GET 'https://xtz-index.nownodes.io/v1/tokens/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/tokens/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens/count')
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://xtz-index.nownodes.io/v1/tokens/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/tokens/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tokens/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens/count')
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

Get tokens

GET

https://xtz-index.nownodes.io/v1/tokens

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of tokens.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id. Note, this is not the same as tokenId nat value.
Click on the parameter to expand more details.

contractAccountParameter | nullquery

Filter by contract address.
Click on the parameter to expand more details.

tokenIdNatParameter | nullquery

Filter by tokenId (for FA1.2 tokens tokenId is always "0").
Click on the parameter to expand more details.

standardTokenStandardParameter | nullquery

Filter by token standard (fa1.2 or fa2).
Click on the parameter to expand more details.

firstMinterAccountParameter | nullquery

Filter by address of the first minter.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block where the token was first seen.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the token was first seen.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block where the token was last seen.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the token was last seen.
Click on the parameter to expand more details.

metadataJsonParameter | nullquery

indexedAtInt32NullParameter | nullquery

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get tokens

curl -X GET 'https://xtz-index.nownodes.io/v1/tokens'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tokens')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/tokens";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tokens')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "id": 0,
    "contract": {
      "alias": "string",
      "address": "string"
    },
    "tokenId": "string",
    "standard": "string",
    "firstMinter": {
      "alias": "string",
      "address": "string"
    },
    "firstLevel": 0,
    "firstTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "lastTime": "2024-01-15T09:30:00Z",
    "transfersCount": 0,
    "balancesCount": 0,
    "holdersCount": 0,
    "totalMinted": "string",
    "totalBurned": "string",
    "totalSupply": "string"
  }
]

Get token balances count

GET

https://xtz-index.nownodes.io/v1/tokens/balances/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a total number of token balances.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

accountAccountParameter | nullquery

Filter by account address.
Click on the parameter to expand more details.

token.idInt64Parameter | nullquery

Filter by internal TzKT id. Note, this is not the same as tokenId.
Click on the parameter to expand more details.

token.contractAccountParameter | nullquery

Filter by contract address.
Click on the parameter to expand more details.

token.tokenIdNatParameter | nullquery

Filter by tokenId (for FA1.2 tokens tokenId is always "0").
Click on the parameter to expand more details.

token.standardTokenStandardParameter | nullquery

Filter by token standard (fa1.2 or fa2).
Click on the parameter to expand more details.

token.metadataJsonParameter | nullquery

Filter by metadata. Note, this parameter supports the following format: token.metadata{.path?}{.mode?}=..., so you can specify a path to a particular field to filter by, for example: ?token.metadata.symbol.in=kUSD,uUSD.
Click on the parameter to expand more details.

balanceNatParameter | nullquery

Filter by balance.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block where the balance was first changed.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the balance was first changed.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block where the balance was last seen.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the balance was last changed.
Click on the parameter to expand more details.

indexedAtInt32NullParameter | nullquery

Response

200OK

Get token balances count

curl -X GET 'https://xtz-index.nownodes.io/v1/tokens/balances/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/tokens/balances/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens/balances/count')
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://xtz-index.nownodes.io/v1/tokens/balances/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/tokens/balances/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tokens/balances/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens/balances/count')
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

Get token balances

GET

https://xtz-index.nownodes.io/v1/tokens/balances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of token balances.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

accountAccountParameter | nullquery

Filter by account address.
Click on the parameter to expand more details.

token.idInt64Parameter | nullquery

Filter by internal TzKT id. Note, this is not the same as tokenId.
Click on the parameter to expand more details.

token.contractAccountParameter | nullquery

Filter by contract address.
Click on the parameter to expand more details.

token.tokenIdNatParameter | nullquery

Filter by tokenId (for FA1.2 tokens tokenId is always "0").
Click on the parameter to expand more details.

token.standardTokenStandardParameter | nullquery

Filter by token standard (fa1.2 or fa2).
Click on the parameter to expand more details.

token.metadataJsonParameter | nullquery

balanceNatParameter | nullquery

Filter by balance.
Click on the parameter to expand more details.

firstLevelInt32Parameter | nullquery

Filter by level of the block where the balance was first changed.
Click on the parameter to expand more details.

firstTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the balance was first changed.
Click on the parameter to expand more details.

lastLevelInt32Parameter | nullquery

Filter by level of the block where the balance was last seen.
Click on the parameter to expand more details.

lastTimeTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the balance was last changed.
Click on the parameter to expand more details.

indexedAtInt32NullParameter | nullquery

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get token balances

curl -X GET 'https://xtz-index.nownodes.io/v1/tokens/balances'

const response = await fetch('https://xtz-index.nownodes.io/v1/tokens/balances', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens/balances')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tokens/balances')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/tokens/balances', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/tokens/balances";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://xtz-index.nownodes.io/v1/tokens/balances', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tokens/balances')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens/balances')
request = Net::HTTP::Get.new(uri)

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

200

[
  {
    "id": 0,
    "account": {
      "alias": "string",
      "address": "string"
    },
    "token": {
      "id": 0,
      "contract": {
        "alias": "string",
        "address": "string"
      },
      "tokenId": "string",
      "standard": "string",
      "totalSupply": "string"
    },
    "balance": "string",
    "balanceValue": 0,
    "transfersCount": 0,
    "firstLevel": 0,
    "firstTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "lastTime": "2024-01-15T09:30:00Z"
  }
]

Get token transfers count

GET

https://xtz-index.nownodes.io/v1/tokens/transfers/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of token transfers.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by level of the block where the transfer was made.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the transfer was made.
Click on the parameter to expand more details.

token.idInt64Parameter | nullquery

Filter by internal TzKT id. Note, this is not the same as tokenId.
Click on the parameter to expand more details.

token.contractAccountParameter | nullquery

Filter by contract address.
Click on the parameter to expand more details.

token.tokenIdNatParameter | nullquery

Filter by tokenId (for FA1.2 tokens tokenId is always "0").
Click on the parameter to expand more details.

token.standardTokenStandardParameter | nullquery

Filter by token standard (fa1.2 or fa2).
Click on the parameter to expand more details.

token.metadataJsonParameter | nullquery

anyofAnyOfParameter | nullquery

fromAccountParameter | nullquery

Filter by sender account address.
Click on the parameter to expand more details.

toAccountParameter | nullquery

Filter by target account address.
Click on the parameter to expand more details.

amountNatParameter | nullquery

Filter by amount.
Click on the parameter to expand more details.

transactionIdInt64NullParameter | nullquery

Filter by id of the transaction, caused the token transfer.
Click on the parameter to expand more details.

originationIdInt64NullParameter | nullquery

Filter by id of the origination, caused the token transfer.
Click on the parameter to expand more details.

migrationIdInt64NullParameter | nullquery

Filter by id of the migration, caused the token transfer.
Click on the parameter to expand more details.

indexedAtInt32NullParameter | nullquery

Response

200OK

Get token transfers count

curl -X GET 'https://xtz-index.nownodes.io/v1/tokens/transfers/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/tokens/transfers/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens/transfers/count')
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://xtz-index.nownodes.io/v1/tokens/transfers/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/tokens/transfers/count', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tokens/transfers/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens/transfers/count')
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

Get token transfers

GET

https://xtz-index.nownodes.io/v1/tokens/transfers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of token transfers.

Parameters

idInt64Parameter | nullquery

Filter by internal TzKT id.
Click on the parameter to expand more details.

levelInt32Parameter | nullquery

Filter by level of the block where the transfer was made.
Click on the parameter to expand more details.

timestampTimestampParameter | nullquery

Filter by timestamp (ISO 8601) of the block where the transfer was made.
Click on the parameter to expand more details.

token.idInt64Parameter | nullquery

Filter by internal TzKT id. Note, this is not the same as tokenId.
Click on the parameter to expand more details.

token.contractAccountParameter | nullquery

Filter by contract address.
Click on the parameter to expand more details.

token.tokenIdNatParameter | nullquery

Filter by tokenId (for FA1.2 tokens tokenId is always "0").
Click on the parameter to expand more details.

token.standardTokenStandardParameter | nullquery

Filter by token standard (fa1.2 or fa2).
Click on the parameter to expand more details.

token.metadataJsonParameter | nullquery

anyofAnyOfParameter | nullquery

fromAccountParameter | nullquery

Filter by sender account address.
Click on the parameter to expand more details.

toAccountParameter | nullquery

Filter by target account address.
Click on the parameter to expand more details.

amountNatParameter | nullquery

Filter by amount.
Click on the parameter to expand more details.

transactionIdInt64NullParameter | nullquery

Filter by id of the transaction, caused the token transfer.
Click on the parameter to expand more details.

originationIdInt64NullParameter | nullquery

Filter by id of the origination, caused the token transfer.
Click on the parameter to expand more details.

migrationIdInt64NullParameter | nullquery

Filter by id of the migration, caused the token transfer.
Click on the parameter to expand more details.

indexedAtInt32NullParameter | nullquery

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get token transfers

curl -X GET 'https://xtz-index.nownodes.io/v1/tokens/transfers'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tokens/transfers')
data = response.json()

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

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/tokens/transfers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tokens/transfers')
data = response.json()

require 'net/http'
require 'json'

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

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

200

[
  {
    "id": 0,
    "level": 0,
    "timestamp": "2024-01-15T09:30:00Z",
    "token": {
      "id": 0,
      "contract": {
        "alias": "string",
        "address": "string"
      },
      "tokenId": "string",
      "standard": "string",
      "totalSupply": "string"
    },
    "from": {
      "alias": "string",
      "address": "string"
    },
    "to": {
      "alias": "string",
      "address": "string"
    },
    "amount": "string",
    "transactionId": 0,
    "originationId": 0,
    "migrationId": 0
  }
]

Get historical token balances

GET

https://xtz-index.nownodes.io/v1/tokens/historical_balances/{level}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of token balances at the end of the specified block. Note, this endpoint is quite heavy, therefore at least one of the filters (account, token.id, token.contract with token.tokenId) must be specified.

Parameters

levelinteger<int32>requiredpath

Level of the block at the end of which historical balances must be calculated

accountAccountParameter | nullquery

Filter by account address.
Click on the parameter to expand more details.

token.idInt64Parameter | nullquery

Filter by internal TzKT id. Note, this is not the same as tokenId.
Click on the parameter to expand more details.

token.contractAccountParameter | nullquery

Filter by contract address.
Click on the parameter to expand more details.

token.tokenIdNatParameter | nullquery

Filter by tokenId (for FA1.2 tokens tokenId is always "0").
Click on the parameter to expand more details.

token.standardTokenStandardParameter | nullquery

Filter by token standard (fa1.2 or fa2).
Click on the parameter to expand more details.

token.metadataJsonParameter | nullquery

balanceNatParameter | nullquery

Filter by balance.
Click on the parameter to expand more details.

sortSortParameter | nullquery

Sorts items (asc or desc) by the specified field. You can see what fields can be used for sorting in the response description, below.
Click on the parameter to expand more details.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped.
Click on the parameter to expand more details.

limitinteger<int32>[0, 10000]query

Maximum number of items to return.

selectSelectionParameter | nullquery

Response

200OK

Get historical token balances

curl -X GET 'https://xtz-index.nownodes.io/v1/tokens/historical_balances/{level}'

const response = await fetch('https://xtz-index.nownodes.io/v1/tokens/historical_balances/{level}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens/historical_balances/{level}')
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://xtz-index.nownodes.io/v1/tokens/historical_balances/{level}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/tokens/historical_balances/{level}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/tokens/historical_balances/{level}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/tokens/historical_balances/{level}')
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

[
  {
    "account": {
      "alias": "string",
      "address": "string"
    },
    "token": {
      "id": 0,
      "contract": {
        "alias": "string",
        "address": "string"
      },
      "tokenId": "string",
      "standard": "string",
      "totalSupply": "string"
    },
    "balance": "string"
  }
]

Voting

Get proposals count

GET

https://xtz-index.nownodes.io/v1/voting/proposals/count

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the total number of protocol proposals.

Response

200OK

Get proposals count

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/proposals/count'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/proposals/count', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/proposals/count')
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://xtz-index.nownodes.io/v1/voting/proposals/count')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/proposals/count', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/voting/proposals/count";
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://xtz-index.nownodes.io/v1/voting/proposals/count', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/proposals/count')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/proposals/count')
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

Get proposals

GET

https://xtz-index.nownodes.io/v1/voting/proposals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of protocol proposals.

Parameters

hashProtocolParameter | nullquery

Filters proposals by hash

epochInt32Parameter | nullquery

Filters proposals by voting epoch

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts proposals by specified field. Supported fields: id (default), upvotes, votingPower.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get proposals

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/proposals'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/proposals', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/proposals')
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://xtz-index.nownodes.io/v1/voting/proposals')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/proposals', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/proposals')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/proposals')
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

[
  {
    "hash": "string",
    "initiator": {
      "alias": "string",
      "address": "string"
    },
    "firstPeriod": 0,
    "lastPeriod": 0,
    "epoch": 0,
    "upvotes": 0,
    "votingPower": 0,
    "status": "string",
    "rolls": 0
  }
]

Get proposal by hash

GET

https://xtz-index.nownodes.io/v1/voting/proposals/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the most recent protocol proposal with the specified hash.

Parameters

hashstringrequiredpath

Proposal hash

Response

200OK

Get proposal by hash

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/proposals/{hash}'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/proposals/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/proposals/{hash}')
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://xtz-index.nownodes.io/v1/voting/proposals/{hash}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/proposals/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/voting/proposals/{hash}";
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://xtz-index.nownodes.io/v1/voting/proposals/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/proposals/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/proposals/{hash}')
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

{
  "hash": "string",
  "initiator": {
    "alias": "string",
    "address": "string"
  },
  "firstPeriod": 0,
  "lastPeriod": 0,
  "epoch": 0,
  "upvotes": 0,
  "votingPower": 0,
  "status": "string",
  "rolls": 0
}

Get voting periods

GET

https://xtz-index.nownodes.io/v1/voting/periods

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of voting periods.

Parameters

firstLevelInt32Parameter | nullquery

Filter by level of the first block of the period.

lastLevelInt32Parameter | nullquery

Filter by level of the last block of the period.

selectSelectParameter | nullquery

sortSortParameter | nullquery

Sorts voting periods by specified field. Supported fields: id (default).

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get voting periods

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/periods'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods')
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://xtz-index.nownodes.io/v1/voting/periods')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/periods')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods')
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

[
  {
    "index": 0,
    "epoch": 0,
    "firstLevel": 0,
    "startTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "endTime": "2024-01-15T09:30:00Z",
    "kind": "string",
    "status": "string",
    "dictator": "string",
    "totalBakers": 0,
    "totalVotingPower": 0,
    "upvotesQuorum": 0,
    "proposalsCount": 0,
    "topUpvotes": 0,
    "topVotingPower": 0,
    "ballotsQuorum": 0,
    "supermajority": 0,
    "yayBallots": 0,
    "yayVotingPower": 0,
    "nayBallots": 0,
    "nayVotingPower": 0,
    "passBallots": 0,
    "passVotingPower": 0,
    "totalRolls": 0,
    "topRolls": 0,
    "yayRolls": 0,
    "nayRolls": 0,
    "passRolls": 0
  }
]

Get voting period by index

GET

https://xtz-index.nownodes.io/v1/voting/periods/{index}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a voting period at the specified index.

Parameters

indexinteger<int32>requiredpath

Voting period index starting from zero

Response

200OK

Get voting period by index

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/periods/{index}'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/{index}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/{index}')
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://xtz-index.nownodes.io/v1/voting/periods/{index}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/{index}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/periods/{index}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/{index}')
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

{
  "index": 0,
  "epoch": 0,
  "firstLevel": 0,
  "startTime": "2024-01-15T09:30:00Z",
  "lastLevel": 0,
  "endTime": "2024-01-15T09:30:00Z",
  "kind": "string",
  "status": "string",
  "dictator": "string",
  "totalBakers": 0,
  "totalVotingPower": 0,
  "upvotesQuorum": 0,
  "proposalsCount": 0,
  "topUpvotes": 0,
  "topVotingPower": 0,
  "ballotsQuorum": 0,
  "supermajority": 0,
  "yayBallots": 0,
  "yayVotingPower": 0,
  "nayBallots": 0,
  "nayVotingPower": 0,
  "passBallots": 0,
  "passVotingPower": 0,
  "totalRolls": 0,
  "topRolls": 0,
  "yayRolls": 0,
  "nayRolls": 0,
  "passRolls": 0
}

Get current voting period

GET

https://xtz-index.nownodes.io/v1/voting/periods/current

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns current voting period.

Response

200OK

Get current voting period

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/periods/current'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/current', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/current')
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://xtz-index.nownodes.io/v1/voting/periods/current')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/current', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/voting/periods/current";
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://xtz-index.nownodes.io/v1/voting/periods/current', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/periods/current')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/current')
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

{
  "index": 0,
  "epoch": 0,
  "firstLevel": 0,
  "startTime": "2024-01-15T09:30:00Z",
  "lastLevel": 0,
  "endTime": "2024-01-15T09:30:00Z",
  "kind": "string",
  "status": "string",
  "dictator": "string",
  "totalBakers": 0,
  "totalVotingPower": 0,
  "upvotesQuorum": 0,
  "proposalsCount": 0,
  "topUpvotes": 0,
  "topVotingPower": 0,
  "ballotsQuorum": 0,
  "supermajority": 0,
  "yayBallots": 0,
  "yayVotingPower": 0,
  "nayBallots": 0,
  "nayVotingPower": 0,
  "passBallots": 0,
  "passVotingPower": 0,
  "totalRolls": 0,
  "topRolls": 0,
  "yayRolls": 0,
  "nayRolls": 0,
  "passRolls": 0
}

Get period voters

GET

https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns voters from the voting period at the specified index.

Parameters

indexinteger<int32>requiredpath

Voting period index starting from zero

statusVoterStatusParameter | nullquery

Filters voters by status (none, upvoted, voted_yay, voted_nay, voted_pass)

sortSortParameter | nullquery

Sorts voters by specified field. Supported fields: id (default), votingPower.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get period voters

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters')
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://xtz-index.nownodes.io/v1/voting/periods/{index}/voters')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters";
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://xtz-index.nownodes.io/v1/voting/periods/{index}/voters', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters')
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

[
  {
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "votingPower": 0,
    "status": "string",
    "rolls": 0
  }
]

Get period voter

GET

https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a voter with the specified address from the voting period at the specified index.

Parameters

indexinteger<int32>requiredpath

Voting period index starting from zero

addressstringrequiredpath

Voter address

Response

200OK

Get period voter

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters/{address}'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters/{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://xtz-index.nownodes.io/v1/voting/periods/{index}/voters/{address}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters/{address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters/{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://xtz-index.nownodes.io/v1/voting/periods/{index}/voters/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/{index}/voters/{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

{
  "delegate": {
    "alias": "string",
    "address": "string"
  },
  "votingPower": 0,
  "status": "string",
  "rolls": 0
}

Get current period voters

GET

https://xtz-index.nownodes.io/v1/voting/periods/current/voters

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns voters from the current period.

Parameters

statusVoterStatusParameter | nullquery

Filters voters by status (none, upvoted, voted_yay, voted_nay, voted_pass)

sortSortParameter | nullquery

Sorts voters by specified field. Supported fields: id (default), votingPower.

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get current period voters

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/periods/current/voters'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/current/voters', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/current/voters')
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://xtz-index.nownodes.io/v1/voting/periods/current/voters')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/current/voters', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/voting/periods/current/voters";
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://xtz-index.nownodes.io/v1/voting/periods/current/voters', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/periods/current/voters')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/current/voters')
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

[
  {
    "delegate": {
      "alias": "string",
      "address": "string"
    },
    "votingPower": 0,
    "status": "string",
    "rolls": 0
  }
]

Get current period voter

GET

https://xtz-index.nownodes.io/v1/voting/periods/current/voters/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a voter with the specified address from the current period.

Parameters

addressstringrequiredpath

Voter address

Response

200OK

Get current period voter

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/periods/current/voters/{address}'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/current/voters/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/current/voters/{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://xtz-index.nownodes.io/v1/voting/periods/current/voters/{address}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/periods/current/voters/{address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/voting/periods/current/voters/{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://xtz-index.nownodes.io/v1/voting/periods/current/voters/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/periods/current/voters/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/periods/current/voters/{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

{
  "delegate": {
    "alias": "string",
    "address": "string"
  },
  "votingPower": 0,
  "status": "string",
  "rolls": 0
}

Get voting epochs

GET

https://xtz-index.nownodes.io/v1/voting/epochs

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of voting epochs.

Parameters

sortSortParameter | nullquery

Sorts voting epochs by specified field. Supported fields: id (default).

offsetOffsetParameter | nullquery

Specifies which or how many items should be skipped

limitinteger<int32>[0, 10000]100query

Maximum number of items to return

Response

200OK

Get voting epochs

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/epochs'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/epochs', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/epochs')
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://xtz-index.nownodes.io/v1/voting/epochs')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/epochs', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/epochs')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/epochs')
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

[
  {
    "index": 0,
    "firstLevel": 0,
    "startTime": "2024-01-15T09:30:00Z",
    "lastLevel": 0,
    "endTime": "2024-01-15T09:30:00Z",
    "status": "string",
    "periods": [
      {
        "index": 0,
        "epoch": 0,
        "firstLevel": 0,
        "startTime": "2024-01-15T09:30:00Z",
        "lastLevel": 0,
        "endTime": "2024-01-15T09:30:00Z",
        "kind": "string",
        "status": "string",
        "dictator": "string",
        "totalBakers": 0,
        "totalVotingPower": 0,
        "upvotesQuorum": 0,
        "proposalsCount": 0,
        "topUpvotes": 0,
        "topVotingPower": 0,
        "ballotsQuorum": 0,
        "supermajority": 0,
        "yayBallots": 0,
        "yayVotingPower": 0,
        "nayBallots": 0,
        "nayVotingPower": 0,
        "passBallots": 0,
        "passVotingPower": 0,
        "totalRolls": 0,
        "topRolls": 0,
        "yayRolls": 0,
        "nayRolls": 0,
        "passRolls": 0
      }
    ],
    "proposals": [
      {
        "hash": "string",
        "initiator": {
          "alias": "string",
          "address": "string"
        },
        "firstPeriod": 0,
        "lastPeriod": 0,
        "epoch": 0,
        "upvotes": 0,
        "votingPower": 0,
        "status": "string",
        "rolls": 0
      }
    ]
  }
]

Get voting epoch by index

GET

https://xtz-index.nownodes.io/v1/voting/epochs/{index}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a voting epoch at the specified index.

Parameters

indexinteger<int32>requiredpath

Voting epoch index starting from zero

Response

200OK

Get voting epoch by index

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/epochs/{index}'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/epochs/{index}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/epochs/{index}')
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://xtz-index.nownodes.io/v1/voting/epochs/{index}')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/epochs/{index}', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/epochs/{index}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/epochs/{index}')
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

{
  "index": 0,
  "firstLevel": 0,
  "startTime": "2024-01-15T09:30:00Z",
  "lastLevel": 0,
  "endTime": "2024-01-15T09:30:00Z",
  "status": "string",
  "periods": [
    {
      "index": 0,
      "epoch": 0,
      "firstLevel": 0,
      "startTime": "2024-01-15T09:30:00Z",
      "lastLevel": 0,
      "endTime": "2024-01-15T09:30:00Z",
      "kind": "string",
      "status": "string",
      "dictator": "string",
      "totalBakers": 0,
      "totalVotingPower": 0,
      "upvotesQuorum": 0,
      "proposalsCount": 0,
      "topUpvotes": 0,
      "topVotingPower": 0,
      "ballotsQuorum": 0,
      "supermajority": 0,
      "yayBallots": 0,
      "yayVotingPower": 0,
      "nayBallots": 0,
      "nayVotingPower": 0,
      "passBallots": 0,
      "passVotingPower": 0,
      "totalRolls": 0,
      "topRolls": 0,
      "yayRolls": 0,
      "nayRolls": 0,
      "passRolls": 0
    }
  ],
  "proposals": [
    {
      "hash": "string",
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "firstPeriod": 0,
      "lastPeriod": 0,
      "epoch": 0,
      "upvotes": 0,
      "votingPower": 0,
      "status": "string",
      "rolls": 0
    }
  ]
}

Get current voting epoch

GET

https://xtz-index.nownodes.io/v1/voting/epochs/current

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current voting epoch

Response

200OK

Get current voting epoch

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/epochs/current'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/epochs/current', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/epochs/current')
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://xtz-index.nownodes.io/v1/voting/epochs/current')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/epochs/current', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/voting/epochs/current";
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://xtz-index.nownodes.io/v1/voting/epochs/current', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/epochs/current')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/epochs/current')
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

{
  "index": 0,
  "firstLevel": 0,
  "startTime": "2024-01-15T09:30:00Z",
  "lastLevel": 0,
  "endTime": "2024-01-15T09:30:00Z",
  "status": "string",
  "periods": [
    {
      "index": 0,
      "epoch": 0,
      "firstLevel": 0,
      "startTime": "2024-01-15T09:30:00Z",
      "lastLevel": 0,
      "endTime": "2024-01-15T09:30:00Z",
      "kind": "string",
      "status": "string",
      "dictator": "string",
      "totalBakers": 0,
      "totalVotingPower": 0,
      "upvotesQuorum": 0,
      "proposalsCount": 0,
      "topUpvotes": 0,
      "topVotingPower": 0,
      "ballotsQuorum": 0,
      "supermajority": 0,
      "yayBallots": 0,
      "yayVotingPower": 0,
      "nayBallots": 0,
      "nayVotingPower": 0,
      "passBallots": 0,
      "passVotingPower": 0,
      "totalRolls": 0,
      "topRolls": 0,
      "yayRolls": 0,
      "nayRolls": 0,
      "passRolls": 0
    }
  ],
  "proposals": [
    {
      "hash": "string",
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "firstPeriod": 0,
      "lastPeriod": 0,
      "epoch": 0,
      "upvotes": 0,
      "votingPower": 0,
      "status": "string",
      "rolls": 0
    }
  ]
}

Get latest voting

GET

https://xtz-index.nownodes.io/v1/voting/epochs/latest_voting

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the latest epoch with at least one proposal

Response

200OK

Get latest voting

curl -X GET 'https://xtz-index.nownodes.io/v1/voting/epochs/latest_voting'

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/epochs/latest_voting', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/epochs/latest_voting')
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://xtz-index.nownodes.io/v1/voting/epochs/latest_voting')
data = response.json()

const response = await fetch('https://xtz-index.nownodes.io/v1/voting/epochs/latest_voting', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://xtz-index.nownodes.io/v1/voting/epochs/latest_voting";
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://xtz-index.nownodes.io/v1/voting/epochs/latest_voting', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://xtz-index.nownodes.io/v1/voting/epochs/latest_voting')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://xtz-index.nownodes.io/v1/voting/epochs/latest_voting')
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

{
  "index": 0,
  "firstLevel": 0,
  "startTime": "2024-01-15T09:30:00Z",
  "lastLevel": 0,
  "endTime": "2024-01-15T09:30:00Z",
  "status": "string",
  "periods": [
    {
      "index": 0,
      "epoch": 0,
      "firstLevel": 0,
      "startTime": "2024-01-15T09:30:00Z",
      "lastLevel": 0,
      "endTime": "2024-01-15T09:30:00Z",
      "kind": "string",
      "status": "string",
      "dictator": "string",
      "totalBakers": 0,
      "totalVotingPower": 0,
      "upvotesQuorum": 0,
      "proposalsCount": 0,
      "topUpvotes": 0,
      "topVotingPower": 0,
      "ballotsQuorum": 0,
      "supermajority": 0,
      "yayBallots": 0,
      "yayVotingPower": 0,
      "nayBallots": 0,
      "nayVotingPower": 0,
      "passBallots": 0,
      "passVotingPower": 0,
      "totalRolls": 0,
      "topRolls": 0,
      "yayRolls": 0,
      "nayRolls": 0,
      "passRolls": 0
    }
  ],
  "proposals": [
    {
      "hash": "string",
      "initiator": {
        "alias": "string",
        "address": "string"
      },
      "firstPeriod": 0,
      "lastPeriod": 0,
      "epoch": 0,
      "upvotes": 0,
      "votingPower": 0,
      "status": "string",
      "rolls": 0
    }
  ]
}

Documentation

How to migrate to NOWNodes

Authentication

Indexer

Accounts

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

BigMaps

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Blocks

Authorizations

Response