Blockfrost Cardano API

v1.0.0

Base URL

https://ada-blockfrost.nownodes.ioNOWNodes Cardano blockfrost endpoint.

Blockfrost API for the Cardano blockchain. Provides endpoints for querying health status, accounts, addresses, assets, blocks, epochs, genesis configuration, metadata, network eras, stake pools, scripts, transactions, and utility operations. Authentication is performed via an API key passed in the api-key header.

Authentication

api-keyAuthapiKey

NOWNodes API key passed in the api-key header.

API Key: api-key in header

Blockfrost

Health

Health operations.

API Health Status

GET

https://ada-blockfrost.nownodes.io/health

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current health status of the Blockfrost backend. When the service is fully operational and synchronised with the Cardano blockchain the is_healthy flag is true.

Response

200OK

HTTP 200 response for getHealthStatus.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

API Health Status

curl -X GET 'https://ada-blockfrost.nownodes.io/health'

const response = await fetch('https://ada-blockfrost.nownodes.io/health', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/health')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/health')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/health', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/health";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/health', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/health')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/health')
request = Net::HTTP::Get.new(uri)

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

{
  "status": "ok"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

API Clock Synchronisation

GET

https://ada-blockfrost.nownodes.io/health/clock

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current UNIX timestamp (in milliseconds) reported by the Blockfrost server. Useful for detecting clock drift between the client system and the Blockfrost infrastructure.

Response

200OK

HTTP 200 response for getHealthClock.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

API Clock Synchronisation

curl -X GET 'https://ada-blockfrost.nownodes.io/health/clock'

const response = await fetch('https://ada-blockfrost.nownodes.io/health/clock', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/health/clock')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/health/clock')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/health/clock', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/health/clock";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/health/clock', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/health/clock')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/health/clock')
request = Net::HTTP::Get.new(uri)

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

{
  "server_time": 1783421965000
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Accounts

Accounts operations.

Account information

GET

https://ada-blockfrost.nownodes.io/accounts/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns on-chain information about a specific Cardano stake account identified by its Bech32 stake address. Includes delegation status, controlled balance, reward totals, and MIR sums.

Parameters

stake_addressstringrequiredpath

Bech32-encoded stake address starting with 'stake1' prefix. This is the staking credential associated with a Cardano wallet

addressstringrequiredpath

Cardano payment address in Bech32 format.

Response

200OK

HTTP 200 response for getAccount.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Account information

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

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

{
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "active": true,
  "registered": true,
  "active_epoch": 641,
  "controlled_amount": "25955728541",
  "rewards_sum": "15655779099",
  "withdrawals_sum": "12987239562",
  "withdrawable_amount": "2668539537",
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "drep_id": "drep_always_no_confidence"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Account reward history

GET

https://ada-blockfrost.nownodes.io/accounts/{address}/rewards

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of all staking rewards received by the specified stake address, broken down by epoch.

Parameters

addressstringrequiredpath

Bech32-encoded stake address of the account whose reward history is being queried.

Response

200OK

HTTP 200 response for getAccountRewards.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Account reward history

curl -X GET 'https://ada-blockfrost.nownodes.io/accounts/{address}/rewards'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{address}/rewards')
data = response.json()

require 'net/http'
require 'json'

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

{
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "active": true,
  "registered": true,
  "active_epoch": 641,
  "controlled_amount": "25955728541",
  "rewards_sum": "15655779099",
  "withdrawals_sum": "12987239562",
  "withdrawable_amount": "2668539537",
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "drep_id": "drep_always_no_confidence"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Account registration history

GET

https://ada-blockfrost.nownodes.io/accounts/{stake_address}/registrations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves the complete history of registration and deregistration events for a specific Cardano stake account, including transaction details and timestamps

Parameters

stake_addressstringrequiredpath

The Bech32-encoded Cardano stake address (starts with 'stake1') for which to retrieve registration history

Response

200OK

HTTP 200 response for getAccountRegistrations.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Account registration history

curl -X GET 'https://ada-blockfrost.nownodes.io/accounts/{stake_address}/registrations'

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/registrations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/registrations')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/registrations')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/registrations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/accounts/{stake_address}/registrations";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/registrations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/registrations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/registrations')
request = Net::HTTP::Get.new(uri)

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

{
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "active": true,
  "registered": true,
  "active_epoch": 641,
  "controlled_amount": "25955728541",
  "rewards_sum": "15655779099",
  "withdrawals_sum": "12987239562",
  "withdrawable_amount": "2668539537",
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "drep_id": "drep_always_no_confidence"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Account withdrawals

GET

https://ada-blockfrost.nownodes.io/accounts/{address}/withdrawals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves the complete history of reward withdrawals for a specific Cardano stake account. Withdrawals transfer accumulated staking rewards from the reward account to a regular address for spending

Parameters

stake_addressstringrequiredpath

The Bech32-encoded Cardano stake address (starts with 'stake1') for which to retrieve withdrawal history

addressstringrequiredpath

Cardano payment address in Bech32 format.

Response

200OK

HTTP 200 response for getAccountWithdrawals.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Account withdrawals

curl -X GET 'https://ada-blockfrost.nownodes.io/accounts/{address}/withdrawals'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{address}/withdrawals')
data = response.json()

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

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/accounts/{address}/withdrawals";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{address}/withdrawals')
data = response.json()

require 'net/http'
require 'json'

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

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

{
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "active": true,
  "registered": true,
  "active_epoch": 641,
  "controlled_amount": "25955728541",
  "rewards_sum": "15655779099",
  "withdrawals_sum": "12987239562",
  "withdrawable_amount": "2668539537",
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "drep_id": "drep_always_no_confidence"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Account MIRs

GET

https://ada-blockfrost.nownodes.io/accounts/{address}/mirs

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves the complete history of Move Instantaneous Rewards (MIR) for a specific Cardano stake account. MIR certificates are used to transfer funds from the Cardano reserves or treasury directly to stake addresses, typically during special distribution events or protocol transitions

Parameters

stake_addressstringrequiredpath

The Bech32-encoded Cardano stake address (starts with 'stake1') for which to retrieve MIR history

addressstringrequiredpath

Cardano payment address in Bech32 format.

Response

200OK

HTTP 200 response for getAccountMIRs.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Account MIRs

curl -X GET 'https://ada-blockfrost.nownodes.io/accounts/{address}/mirs'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{address}/mirs')
data = response.json()

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

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/accounts/{address}/mirs";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{address}/mirs')
data = response.json()

require 'net/http'
require 'json'

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

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

{
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "active": true,
  "registered": true,
  "active_epoch": 641,
  "controlled_amount": "25955728541",
  "rewards_sum": "15655779099",
  "withdrawals_sum": "12987239562",
  "withdrawable_amount": "2668539537",
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "drep_id": "drep_always_no_confidence"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Associated addresses

GET

https://ada-blockfrost.nownodes.io/accounts/{address}/addresses

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all payment (UTXO) addresses that are controlled by the given stake key.

Parameters

addressstringrequiredpath

Bech32-encoded stake address used to look up associated payment addresses.

Response

200OK

HTTP 200 response for getAccountAddresses.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Associated addresses

curl -X GET 'https://ada-blockfrost.nownodes.io/accounts/{address}/addresses'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses')
data = response.json()

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

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/accounts/{address}/addresses";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses')
data = response.json()

require 'net/http'
require 'json'

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

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

{
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "active": true,
  "registered": true,
  "active_epoch": 641,
  "controlled_amount": "25955728541",
  "rewards_sum": "15655779099",
  "withdrawals_sum": "12987239562",
  "withdrawable_amount": "2668539537",
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "drep_id": "drep_always_no_confidence"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Assets in associated addresses

GET

https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/assets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all native assets held across every payment address controlled by the given stake key.

Parameters

addressstringrequiredpath

Bech32-encoded stake address whose controlled assets are queried.

Response

200OK

HTTP 200 response for getAccountAddressAssets.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Assets in associated addresses

curl -X GET 'https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/assets'

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/assets', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/assets')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/assets')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/assets', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/assets";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/assets', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/assets')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/assets')
request = Net::HTTP::Get.new(uri)

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

{
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "active": true,
  "registered": true,
  "active_epoch": 641,
  "controlled_amount": "25955728541",
  "rewards_sum": "15655779099",
  "withdrawals_sum": "12987239562",
  "withdrawable_amount": "2668539537",
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "drep_id": "drep_always_no_confidence"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Total balance of controlled addresses

GET

https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/total

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns aggregated balance statistics for all payment addresses associated with the given stake key.

Parameters

addressstringrequiredpath

Bech32-encoded stake address whose aggregated totals are queried.

Response

200OK

HTTP 200 response for getAccountAddressesTotal.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Total balance of controlled addresses

curl -X GET 'https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/total'

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/total', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/total')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/total')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/total', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/total";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/total', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/total')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/accounts/{address}/addresses/total')
request = Net::HTTP::Get.new(uri)

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

{
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "active": true,
  "registered": true,
  "active_epoch": 641,
  "controlled_amount": "25955728541",
  "rewards_sum": "15655779099",
  "withdrawals_sum": "12987239562",
  "withdrawable_amount": "2668539537",
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "drep_id": "drep_always_no_confidence"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Account stake history

GET

https://ada-blockfrost.nownodes.io/accounts/{stake_address}/history

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a chronological list of the account's staking history showing the delegated amount and target pool for each epoch in which the stake key was active.

Parameters

stake_addressstringrequiredpath

Bech32-encoded stake address whose staking history is being queried.

Response

200OK

HTTP 200 response for getAccountHistory.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

404Not Found

Stake address not found.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Account stake history

curl -X GET 'https://ada-blockfrost.nownodes.io/accounts/{stake_address}/history'

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/history', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/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://ada-blockfrost.nownodes.io/accounts/{stake_address}/history')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/history', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/accounts/{stake_address}/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://ada-blockfrost.nownodes.io/accounts/{stake_address}/history', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/history')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/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)

{
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "active": true,
  "registered": true,
  "active_epoch": 641,
  "controlled_amount": "25955728541",
  "rewards_sum": "15655779099",
  "withdrawals_sum": "12987239562",
  "withdrawable_amount": "2668539537",
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "drep_id": "drep_always_no_confidence"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Account delegation history

GET

https://ada-blockfrost.nownodes.io/accounts/{stake_address}/delegations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Retrieves the complete history of delegation events for a specific Cardano stake account. Each entry represents a transaction where the account changed its delegation to a stake pool, including the effective epoch, amounts, and transaction details

Parameters

stake_addressstringrequiredpath

The Bech32-encoded Cardano stake address (starts with 'stake1') for which to retrieve delegation history

Response

200OK

HTTP 200 response for getAccountDelegations.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Account delegation history

curl -X GET 'https://ada-blockfrost.nownodes.io/accounts/{stake_address}/delegations'

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/delegations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/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://ada-blockfrost.nownodes.io/accounts/{stake_address}/delegations')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/delegations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/accounts/{stake_address}/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://ada-blockfrost.nownodes.io/accounts/{stake_address}/delegations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/delegations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/accounts/{stake_address}/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)

{
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "active": true,
  "registered": true,
  "active_epoch": 641,
  "controlled_amount": "25955728541",
  "rewards_sum": "15655779099",
  "withdrawals_sum": "12987239562",
  "withdrawable_amount": "2668539537",
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "drep_id": "drep_always_no_confidence"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Addresses

Addresses operations.

Get address information

GET

https://ada-blockfrost.nownodes.io/addresses/{address}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns detailed information about a specific Cardano address including current balance, address type, and linked stake address.

Parameters

addressstringrequiredpath

Bech32-encoded Cardano address to query.

Response

200OK

HTTP 200 response for getAddress.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get address information

curl -X GET 'https://ada-blockfrost.nownodes.io/addresses/{address}'

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{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://ada-blockfrost.nownodes.io/addresses/{address}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/addresses/{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://ada-blockfrost.nownodes.io/addresses/{address}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/addresses/{address}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{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)

{
  "address": "addr1qx2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3a3cw7eygp6r7g4w0n4q3v4qaryeuw8c9r9j4q4g4q3f4zq0j6x8",
  "amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "type": "shelley",
  "script": false
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get address totals

GET

https://ada-blockfrost.nownodes.io/addresses/{address}/total

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns cumulative transaction statistics for a specific address including total ADA received, sent, and transaction count.

Parameters

addressstringrequiredpath

Bech32-encoded Cardano address to query.

Response

200OK

HTTP 200 response for getAddressTotals.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get address totals

curl -X GET 'https://ada-blockfrost.nownodes.io/addresses/{address}/total'

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/total', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{address}/total')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/addresses/{address}/total')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/total', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/addresses/{address}/total";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/total', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/addresses/{address}/total')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{address}/total')
request = Net::HTTP::Get.new(uri)

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

{
  "address": "addr1qx2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3a3cw7eygp6r7g4w0n4q3v4qaryeuw8c9r9j4q4g4q3f4zq0j6x8",
  "amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "type": "shelley",
  "script": false
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get UTXOs by asset

GET

https://ada-blockfrost.nownodes.io/addresses/{address}/utxos/{asset}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all unspent transaction outputs (UTXOs) at the given address that contain the specified native asset.

Parameters

addressstringrequiredpath

Bech32-encoded Cardano address to query for UTXOs.

assetstringrequiredpath

Asset unit identifier formed by concatenating the policy ID and hex-encoded asset name.

Response

200OK

HTTP 200 response for getAddressUtxosByAsset.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get UTXOs by asset

curl -X GET 'https://ada-blockfrost.nownodes.io/addresses/{address}/utxos/{asset}'

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos/{asset}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos/{asset}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos/{asset}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos/{asset}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/addresses/{address}/utxos/{asset}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos/{asset}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos/{asset}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos/{asset}')
request = Net::HTTP::Get.new(uri)

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

{
  "address": "addr1qx2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3a3cw7eygp6r7g4w0n4q3v4qaryeuw8c9r9j4q4g4q3f4zq0j6x8",
  "amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "type": "shelley",
  "script": false
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get address transactions

GET

https://ada-blockfrost.nownodes.io/addresses/{address}/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of transactions involving the specified address, ordered by block height.

Parameters

addressstringrequiredpath

Bech32-encoded Cardano address whose transaction history is being queried.

countinteger<= 100100query

Maximum number of transactions to return per page. Defaults to 100; cannot exceed 100.

pageinteger1query

Page number for pagination. Defaults to 1.

orderstringascdescdescquery

Sort order of the results by block height. "asc" for ascending, "desc" for descending.

Response

200OK

HTTP 200 response for getAddressTransactions.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get address transactions

curl -X GET 'https://ada-blockfrost.nownodes.io/addresses/{address}/transactions'

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/transactions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{address}/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://ada-blockfrost.nownodes.io/addresses/{address}/transactions')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/transactions', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/addresses/{address}/transactions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{address}/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)

{
  "address": "addr1qx2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3a3cw7eygp6r7g4w0n4q3v4qaryeuw8c9r9j4q4g4q3f4zq0j6x8",
  "amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "type": "shelley",
  "script": false
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get extended address information

GET

https://ada-blockfrost.nownodes.io/addresses/{address}/extended

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns detailed information about a specific Cardano address including current balances with decimal precision metadata and NFT on-chain metadata flags for each held asset, the linked stake address, address type, and whether the address is script-controlled.

Parameters

addressstringrequiredpath

Bech32-encoded Cardano payment address to query.

Response

200OK

HTTP 200 response for getAddressExtended.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

404Not Found

Address not found on the blockchain.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get extended address information

curl -X GET 'https://ada-blockfrost.nownodes.io/addresses/{address}/extended'

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/extended', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{address}/extended')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/addresses/{address}/extended')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/extended', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/addresses/{address}/extended";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/extended', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/addresses/{address}/extended')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{address}/extended')
request = Net::HTTP::Get.new(uri)

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

{
  "address": "addr1qx2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3a3cw7eygp6r7g4w0n4q3v4qaryeuw8c9r9j4q4g4q3f4zq0j6x8",
  "amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "type": "shelley",
  "script": false
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get address UTXOs

GET

https://ada-blockfrost.nownodes.io/addresses/{address}/utxos

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all unspent transaction outputs (UTXOs) currently held at the specified Cardano address. Each UTXO includes the originating transaction hash, output index, value breakdown, optional datum information, and reference script hash.

Parameters

addressstringrequiredpath

Bech32-encoded Cardano payment address whose UTXOs are being queried.

Response

200OK

HTTP 200 response for getAddressUtxos.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

404Not Found

Address not found.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get address UTXOs

curl -X GET 'https://ada-blockfrost.nownodes.io/addresses/{address}/utxos'

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/addresses/{address}/utxos";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/addresses/{address}/utxos')
request = Net::HTTP::Get.new(uri)

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

{
  "address": "addr1qx2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3a3cw7eygp6r7g4w0n4q3v4qaryeuw8c9r9j4q4g4q3f4zq0j6x8",
  "amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "stake_address": "stake1uyqcufz4slpgq92jayfdhy8n4mnlrqjrjfprxntzmmedd6q7zzut8",
  "type": "shelley",
  "script": false
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Assets

Assets operations.

List all assets

GET

https://ada-blockfrost.nownodes.io/assets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of all native assets minted on the Cardano blockchain.

Parameters

pageinteger1query

Page number for pagination. Defaults to 1.

countinteger<= 100100query

Maximum number of results per page. Defaults to 100; max 100.

orderstringascdescdescquery

Sort order of the results. "asc" for ascending, "desc" for descending.

Response

200OK

HTTP 200 response for listAssets.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

List all assets

curl -X GET 'https://ada-blockfrost.nownodes.io/assets'

const response = await fetch('https://ada-blockfrost.nownodes.io/assets', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/assets')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/assets', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/assets";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/assets', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/assets')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "asset": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
    "quantity": "221350388"
  }
]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Asset information

GET

https://ada-blockfrost.nownodes.io/assets/{asset}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns detailed on-chain metadata, supply information, and optional off-chain metadata for a specific native asset.

Parameters

assetstringrequiredpath

Asset unit identifier (policy ID concatenated with the hex-encoded asset name).

Response

200OK

HTTP 200 response for getAsset.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Asset information

curl -X GET 'https://ada-blockfrost.nownodes.io/assets/{asset}'

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/{asset}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets/{asset}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/assets/{asset}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/{asset}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/assets/{asset}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/{asset}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/assets/{asset}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets/{asset}')
request = Net::HTTP::Get.new(uri)

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

{
  "asset": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
  "policy_id": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a049",
  "asset_name": "4e4459",
  "fingerprint": "asset1rjklcrnsdzqp65wjgrg55sy9723kw09mlgvlc3",
  "quantity": "221350388",
  "initial_mint_tx_hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "mint_or_burn_count": 1
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Asset mint/burn history

GET

https://ada-blockfrost.nownodes.io/assets/{asset}/history

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated history of all mint and burn events for the specified native asset.

Parameters

assetstringrequiredpath

Asset unit identifier (policy ID + hex-encoded asset name).

pageinteger1query

Page number for pagination. Defaults to 1.

countinteger<= 100100query

Maximum number of results per page. Defaults to 100; max 100.

orderstringascdescdescquery

Sort order of the results.

Response

200OK

HTTP 200 response for getAssetHistory.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Asset mint/burn history

curl -X GET 'https://ada-blockfrost.nownodes.io/assets/{asset}/history'

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/{asset}/history', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets/{asset}/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://ada-blockfrost.nownodes.io/assets/{asset}/history')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/{asset}/history', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/assets/{asset}/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://ada-blockfrost.nownodes.io/assets/{asset}/history', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/assets/{asset}/history')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets/{asset}/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)

[
  {
    "asset": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
    "quantity": "221350388"
  }
]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Asset transaction history

GET

https://ada-blockfrost.nownodes.io/assets/{asset}/transactions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of all transactions involving the specified native asset.

Parameters

assetstringrequiredpath

Asset unit identifier (policy ID + hex-encoded asset name).

pageinteger1query

Page number for pagination. Defaults to 1.

countinteger<= 100100query

Maximum number of results per page. Defaults to 100; max 100.

orderstringascdescdescquery

Sort order of the results.

Response

200OK

HTTP 200 response for getAssetTransactions.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Asset transaction history

curl -X GET 'https://ada-blockfrost.nownodes.io/assets/{asset}/transactions'

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/{asset}/transactions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets/{asset}/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://ada-blockfrost.nownodes.io/assets/{asset}/transactions')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/{asset}/transactions', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/assets/{asset}/transactions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets/{asset}/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)

[
  {
    "asset": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
    "quantity": "221350388"
  }
]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Asset distribution

GET

https://ada-blockfrost.nownodes.io/assets/{asset}/addresses

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of all addresses that hold the specified native asset along with the quantity each holds.

Parameters

assetstringrequiredpath

Asset unit identifier (policy ID + hex-encoded asset name).

pageinteger1query

Page number for pagination. Defaults to 1.

countinteger<= 100100query

Maximum number of results per page. Defaults to 100; max 100.

orderstringascdescdescquery

Sort order of the results.

Response

200OK

HTTP 200 response for getAssetAddresses.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Asset distribution

curl -X GET 'https://ada-blockfrost.nownodes.io/assets/{asset}/addresses'

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/{asset}/addresses', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets/{asset}/addresses')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/assets/{asset}/addresses')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/{asset}/addresses', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/assets/{asset}/addresses";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/{asset}/addresses', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/assets/{asset}/addresses')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets/{asset}/addresses')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "asset": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
    "quantity": "221350388"
  }
]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Assets by policy

GET

https://ada-blockfrost.nownodes.io/assets/policy/{policy_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all native assets minted under the specified minting policy ID.

Parameters

policy_idstringrequiredpath

Blake2b-224 hash of the minting policy script.

pageinteger1query

Page number for pagination. Defaults to 1.

countinteger<= 100100query

Maximum number of results per page. Defaults to 100; max 100.

orderstringascdescdescquery

Sort order of the results.

Response

200OK

HTTP 200 response for getAssetsByPolicy.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Assets by policy

curl -X GET 'https://ada-blockfrost.nownodes.io/assets/policy/{policy_id}'

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/policy/{policy_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets/policy/{policy_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://ada-blockfrost.nownodes.io/assets/policy/{policy_id}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/assets/policy/{policy_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/assets/policy/{policy_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://ada-blockfrost.nownodes.io/assets/policy/{policy_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/assets/policy/{policy_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/assets/policy/{policy_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)

[
  {
    "asset": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
    "quantity": "221350388"
  }
]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Blocks

Blocks operations.

Get latest block

GET

https://ada-blockfrost.nownodes.io/blocks/latest

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns full details of the most recently minted block on the Cardano blockchain.

Response

200OK

HTTP 200 response for getLatestBlock.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get latest block

curl -X GET 'https://ada-blockfrost.nownodes.io/blocks/latest'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/latest')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/latest')
data = response.json()

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

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/blocks/latest";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/latest')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/latest')
request = Net::HTTP::Get.new(uri)

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

{
  "time": 1783421965,
  "height": 13646894,
  "hash": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "slot": 191855674,
  "epoch": 641,
  "epoch_slot": 306874,
  "slot_leader": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "size": 2084,
  "tx_count": 4,
  "output": "76480267030",
  "fees": "955311",
  "previous_block": "2895f4973b87ef8632957a3b0c849fd46089dd776c21d799b996c210045b4105",
  "next_block": null,
  "confirmations": 0
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get transactions in latest block

GET

https://ada-blockfrost.nownodes.io/blocks/latest/txs

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of transaction hashes included in the most recently minted block.

Response

200OK

HTTP 200 response for getLatestBlockTxs.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get transactions in latest block

curl -X GET 'https://ada-blockfrost.nownodes.io/blocks/latest/txs'

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/latest/txs', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/latest/txs')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/latest/txs')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/latest/txs', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/blocks/latest/txs";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/latest/txs', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/latest/txs')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/latest/txs')
request = Net::HTTP::Get.new(uri)

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

{
  "time": 1783421965,
  "height": 13646894,
  "hash": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "slot": 191855674,
  "epoch": 641,
  "epoch_slot": 306874,
  "slot_leader": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "size": 2084,
  "tx_count": 4,
  "output": "76480267030",
  "fees": "955311",
  "previous_block": "2895f4973b87ef8632957a3b0c849fd46089dd776c21d799b996c210045b4105",
  "next_block": null,
  "confirmations": 0
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get block by ID or hash

GET

https://ada-blockfrost.nownodes.io/blocks/{block_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns full details of a specific block identified by its Blake2b-256 hash or block number.

Parameters

block_idstringrequiredpath

Block identifier — either the Blake2b-256 block hash or the integer block number (height).

Response

200OK

HTTP 200 response for getBlockById.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get block by ID or hash

curl -X GET 'https://ada-blockfrost.nownodes.io/blocks/{block_id}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/{block_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://ada-blockfrost.nownodes.io/blocks/{block_id}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/blocks/{block_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://ada-blockfrost.nownodes.io/blocks/{block_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/{block_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/{block_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)

{
  "time": 1783421965,
  "height": 13646894,
  "hash": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "slot": 191855674,
  "epoch": 641,
  "epoch_slot": 306874,
  "slot_leader": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "size": 2084,
  "tx_count": 4,
  "output": "76480267030",
  "fees": "955311",
  "previous_block": "2895f4973b87ef8632957a3b0c849fd46089dd776c21d799b996c210045b4105",
  "next_block": null,
  "confirmations": 0
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get next blocks

GET

https://ada-blockfrost.nownodes.io/blocks/{block_id}/next

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of blocks that follow the specified block.

Parameters

block_idstringrequiredpath

Block hash or block number of the starting block.

Response

200OK

HTTP 200 response for getNextBlocks.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get next blocks

curl -X GET 'https://ada-blockfrost.nownodes.io/blocks/{block_id}/next'

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block_id}/next', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/{block_id}/next')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/{block_id}/next')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block_id}/next', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/blocks/{block_id}/next";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block_id}/next', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/{block_id}/next')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/{block_id}/next')
request = Net::HTTP::Get.new(uri)

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

{
  "time": 1783421965,
  "height": 13646894,
  "hash": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "slot": 191855674,
  "epoch": 641,
  "epoch_slot": 306874,
  "slot_leader": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "size": 2084,
  "tx_count": 4,
  "output": "76480267030",
  "fees": "955311",
  "previous_block": "2895f4973b87ef8632957a3b0c849fd46089dd776c21d799b996c210045b4105",
  "next_block": null,
  "confirmations": 0
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get previous blocks

GET

https://ada-blockfrost.nownodes.io/blocks/{block_id}/previous

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of blocks that precede the specified block.

Parameters

block_idstringrequiredpath

Block hash or block number of the starting block.

Response

200OK

HTTP 200 response for getPreviousBlocks.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get previous blocks

curl -X GET 'https://ada-blockfrost.nownodes.io/blocks/{block_id}/previous'

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block_id}/previous', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/{block_id}/previous')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/{block_id}/previous')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block_id}/previous', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/blocks/{block_id}/previous";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block_id}/previous', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/{block_id}/previous')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/{block_id}/previous')
request = Net::HTTP::Get.new(uri)

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

{
  "time": 1783421965,
  "height": 13646894,
  "hash": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "slot": 191855674,
  "epoch": 641,
  "epoch_slot": 306874,
  "slot_leader": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "size": 2084,
  "tx_count": 4,
  "output": "76480267030",
  "fees": "955311",
  "previous_block": "2895f4973b87ef8632957a3b0c849fd46089dd776c21d799b996c210045b4105",
  "next_block": null,
  "confirmations": 0
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get block by slot number

GET

https://ada-blockfrost.nownodes.io/blocks/slot/{slot}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the block that was produced in the specified absolute slot number.

Parameters

slotintegerrequiredpath

Absolute slot number to look up.

Response

200OK

HTTP 200 response for getBlockBySlot.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get block by slot number

curl -X GET 'https://ada-blockfrost.nownodes.io/blocks/slot/{slot}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/slot/{slot}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/slot/{slot}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/blocks/slot/{slot}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/slot/{slot}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/slot/{slot}')
request = Net::HTTP::Get.new(uri)

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

{
  "time": 1783421965,
  "height": 13646894,
  "hash": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "slot": 191855674,
  "epoch": 641,
  "epoch_slot": 306874,
  "slot_leader": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "size": 2084,
  "tx_count": 4,
  "output": "76480267030",
  "fees": "955311",
  "previous_block": "2895f4973b87ef8632957a3b0c849fd46089dd776c21d799b996c210045b4105",
  "next_block": null,
  "confirmations": 0
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get block by epoch and slot

GET

https://ada-blockfrost.nownodes.io/blocks/epoch/{epoch}/slot/{slot}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the block produced at the given slot within the specified epoch.

Parameters

epochintegerrequiredpath

Epoch number in which the slot resides.

slotintegerrequiredpath

Slot number within the specified epoch.

Response

200OK

HTTP 200 response for getBlockByEpochSlot.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get block by epoch and slot

curl -X GET 'https://ada-blockfrost.nownodes.io/blocks/epoch/{epoch}/slot/{slot}'

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/epoch/{epoch}/slot/{slot}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/epoch/{epoch}/slot/{slot}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/epoch/{epoch}/slot/{slot}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/epoch/{epoch}/slot/{slot}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/blocks/epoch/{epoch}/slot/{slot}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/epoch/{epoch}/slot/{slot}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/epoch/{epoch}/slot/{slot}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/epoch/{epoch}/slot/{slot}')
request = Net::HTTP::Get.new(uri)

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

{
  "time": 1783421965,
  "height": 13646894,
  "hash": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "slot": 191855674,
  "epoch": 641,
  "epoch_slot": 306874,
  "slot_leader": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "size": 2084,
  "tx_count": 4,
  "output": "76480267030",
  "fees": "955311",
  "previous_block": "2895f4973b87ef8632957a3b0c849fd46089dd776c21d799b996c210045b4105",
  "next_block": null,
  "confirmations": 0
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get transactions in a block

GET

https://ada-blockfrost.nownodes.io/blocks/{block}/txs

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all transaction hashes included in the specified block.

Parameters

blockstringrequiredpath

Block hash or block number.

Response

200OK

HTTP 200 response for getBlockTxs.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get transactions in a block

curl -X GET 'https://ada-blockfrost.nownodes.io/blocks/{block}/txs'

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block}/txs', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/{block}/txs')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/{block}/txs')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block}/txs', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/blocks/{block}/txs";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block}/txs', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/{block}/txs')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/{block}/txs')
request = Net::HTTP::Get.new(uri)

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

{
  "time": 1783421965,
  "height": 13646894,
  "hash": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "slot": 191855674,
  "epoch": 641,
  "epoch_slot": 306874,
  "slot_leader": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "size": 2084,
  "tx_count": 4,
  "output": "76480267030",
  "fees": "955311",
  "previous_block": "2895f4973b87ef8632957a3b0c849fd46089dd776c21d799b996c210045b4105",
  "next_block": null,
  "confirmations": 0
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get addresses involved in a block

GET

https://ada-blockfrost.nownodes.io/blocks/{block}/addresses

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all unique addresses that appear as inputs or outputs in any transaction within the specified block.

Parameters

blockstringrequiredpath

Block hash or block number.

Response

200OK

HTTP 200 response for getBlockAddresses.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get addresses involved in a block

curl -X GET 'https://ada-blockfrost.nownodes.io/blocks/{block}/addresses'

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block}/addresses', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/{block}/addresses')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/{block}/addresses')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block}/addresses', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/blocks/{block}/addresses";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/blocks/{block}/addresses', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/blocks/{block}/addresses')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/blocks/{block}/addresses')
request = Net::HTTP::Get.new(uri)

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

{
  "time": 1783421965,
  "height": 13646894,
  "hash": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "slot": 191855674,
  "epoch": 641,
  "epoch_slot": 306874,
  "slot_leader": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "size": 2084,
  "tx_count": 4,
  "output": "76480267030",
  "fees": "955311",
  "previous_block": "2895f4973b87ef8632957a3b0c849fd46089dd776c21d799b996c210045b4105",
  "next_block": null,
  "confirmations": 0
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Epochs

Epochs operations.

Get latest epoch

GET

https://ada-blockfrost.nownodes.io/epochs/latest

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the number of the current (latest) epoch on the Cardano blockchain.

Response

200OK

HTTP 200 response for getLatestEpoch.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get latest epoch

curl -X GET 'https://ada-blockfrost.nownodes.io/epochs/latest'

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/latest', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/latest')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/latest')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/latest', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/epochs/latest";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/latest', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/latest')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/latest')
request = Net::HTTP::Get.new(uri)

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

{
  "epoch": 641,
  "start_time": 1783080000,
  "end_time": 1783512000,
  "first_block_time": 1783080001,
  "last_block_time": 1783421965,
  "block_count": 21600,
  "tx_count": 250000,
  "output": "1000000000000",
  "fees": "100000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get latest epoch protocol parameters

GET

https://ada-blockfrost.nownodes.io/epochs/latest/parameters

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the full set of protocol parameters that are active during the current (latest) epoch.

Response

200OK

HTTP 200 response for getLatestEpochParameters.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get latest epoch protocol parameters

curl -X GET 'https://ada-blockfrost.nownodes.io/epochs/latest/parameters'

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/latest/parameters', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/latest/parameters')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/latest/parameters')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/latest/parameters', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/epochs/latest/parameters";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/latest/parameters', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/latest/parameters')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/latest/parameters')
request = Net::HTTP::Get.new(uri)

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

{
  "epoch": 641,
  "start_time": 1783080000,
  "end_time": 1783512000,
  "first_block_time": 1783080001,
  "last_block_time": 1783421965,
  "block_count": 21600,
  "tx_count": 250000,
  "output": "1000000000000",
  "fees": "100000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get next epochs

GET

https://ada-blockfrost.nownodes.io/epochs/{epoch}/next

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of epoch numbers that follow the specified epoch.

Parameters

epochintegerrequiredpath

Starting epoch number.

Response

200OK

HTTP 200 response for getNextEpochs.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get next epochs

curl -X GET 'https://ada-blockfrost.nownodes.io/epochs/{epoch}/next'

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/next', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/next')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/next')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/next', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/epochs/{epoch}/next";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/next', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/next')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/next')
request = Net::HTTP::Get.new(uri)

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

{
  "epoch": 641,
  "start_time": 1783080000,
  "end_time": 1783512000,
  "first_block_time": 1783080001,
  "last_block_time": 1783421965,
  "block_count": 21600,
  "tx_count": 250000,
  "output": "1000000000000",
  "fees": "100000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get previous epochs

GET

https://ada-blockfrost.nownodes.io/epochs/{epoch}/previous

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of epoch numbers that precede the specified epoch.

Parameters

epochintegerrequiredpath

Starting epoch number.

Response

200OK

HTTP 200 response for getPreviousEpochs.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get previous epochs

curl -X GET 'https://ada-blockfrost.nownodes.io/epochs/{epoch}/previous'

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/previous', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/previous')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/previous')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/previous', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/epochs/{epoch}/previous";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/previous', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/previous')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/previous')
request = Net::HTTP::Get.new(uri)

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

{
  "epoch": 641,
  "start_time": 1783080000,
  "end_time": 1783512000,
  "first_block_time": 1783080001,
  "last_block_time": 1783421965,
  "block_count": 21600,
  "tx_count": 250000,
  "output": "1000000000000",
  "fees": "100000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get stake distribution for epoch

GET

https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the stake distribution across all pools for the specified epoch, including active stake and delegator count.

Parameters

epochintegerrequiredpath

Epoch number for which to retrieve the stake snapshot.

pageinteger1query

Page number for pagination. Defaults to 1.

countinteger<= 100100query

Maximum results per page. Defaults to 100; max 100.

orderstringascdescdescquery

Sort order.

Response

200OK

HTTP 200 response for getEpochStakes.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get stake distribution for epoch

curl -X GET 'https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes'

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes')
request = Net::HTTP::Get.new(uri)

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

{
  "epoch": 641,
  "start_time": 1783080000,
  "end_time": 1783512000,
  "first_block_time": 1783080001,
  "last_block_time": 1783421965,
  "block_count": 21600,
  "tx_count": 250000,
  "output": "1000000000000",
  "fees": "100000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get stake for specific pool in epoch

GET

https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes/{pool}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the stake distribution for a single pool during the specified epoch.

Parameters

epochintegerrequiredpath

Epoch number.

poolstringrequiredpath

Bech32-encoded or hex-encoded stake pool ID.

Response

200OK

HTTP 200 response for getEpochStakeByPool.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get stake for specific pool in epoch

curl -X GET 'https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes/{pool}'

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes/{pool}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes/{pool}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes/{pool}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes/{pool}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes/{pool}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes/{pool}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes/{pool}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/stakes/{pool}')
request = Net::HTTP::Get.new(uri)

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

{
  "epoch": 641,
  "start_time": 1783080000,
  "end_time": 1783512000,
  "first_block_time": 1783080001,
  "last_block_time": 1783421965,
  "block_count": 21600,
  "tx_count": 250000,
  "output": "1000000000000",
  "fees": "100000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get blocks in epoch

GET

https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of blocks minted during the specified epoch.

Parameters

epochintegerrequiredpath

Epoch number.

pageinteger1query

Page number. Defaults to 1.

countinteger<= 100100query

Results per page. Defaults to 100; max 100.

orderstringascdescdescquery

Sort order.

Response

200OK

HTTP 200 response for getEpochBlocks.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get blocks in epoch

curl -X GET 'https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks'

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/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://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/epochs/{epoch}/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://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/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)

{
  "epoch": 641,
  "start_time": 1783080000,
  "end_time": 1783512000,
  "first_block_time": 1783080001,
  "last_block_time": 1783421965,
  "block_count": 21600,
  "tx_count": 250000,
  "output": "1000000000000",
  "fees": "100000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get blocks minted by pool in epoch

GET

https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks/{pool}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns blocks minted by a specific stake pool during the given epoch.

Parameters

epochintegerrequiredpath

Epoch number.

poolstringrequiredpath

Bech32 or hex-encoded stake pool ID.

pageinteger1query

Page number. Defaults to 1.

countinteger<= 100100query

Results per page. Max 100.

orderstringascdescdescquery

Sort order.

Response

200OK

HTTP 200 response for getEpochBlocksByPool.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get blocks minted by pool in epoch

curl -X GET 'https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks/{pool}'

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks/{pool}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks/{pool}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks/{pool}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks/{pool}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks/{pool}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks/{pool}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks/{pool}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/blocks/{pool}')
request = Net::HTTP::Get.new(uri)

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

{
  "time": 1783421965,
  "height": 13646894,
  "hash": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "slot": 191855674,
  "epoch": 641,
  "epoch_slot": 306874,
  "slot_leader": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "size": 2084,
  "tx_count": 4,
  "output": "76480267030",
  "fees": "955311",
  "previous_block": "2895f4973b87ef8632957a3b0c849fd46089dd776c21d799b996c210045b4105",
  "next_block": null,
  "confirmations": 0
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get protocol parameters for epoch

GET

https://ada-blockfrost.nownodes.io/epochs/{epoch}/parameters

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the protocol parameters that were active during the specified epoch.

Parameters

epochintegerrequiredpath

Epoch number.

Response

200OK

HTTP 200 response for getEpochParameters.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get protocol parameters for epoch

curl -X GET 'https://ada-blockfrost.nownodes.io/epochs/{epoch}/parameters'

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/parameters', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/parameters')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/parameters')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/parameters', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/epochs/{epoch}/parameters";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}/parameters', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}/parameters')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}/parameters')
request = Net::HTTP::Get.new(uri)

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

{
  "epoch": 641,
  "start_time": 1783080000,
  "end_time": 1783512000,
  "first_block_time": 1783080001,
  "last_block_time": 1783421965,
  "block_count": 21600,
  "tx_count": 250000,
  "output": "1000000000000",
  "fees": "100000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get epoch details

GET

https://ada-blockfrost.nownodes.io/epochs/{epoch}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns comprehensive information about a specific Cardano epoch including its time boundaries, block and transaction counts, total output and fees, and the active stake snapshot.

Parameters

epochintegerrequiredpath

The epoch number to query.

Response

200OK

HTTP 200 response for getEpoch.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

404Not Found

Epoch not found.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get epoch details

curl -X GET 'https://ada-blockfrost.nownodes.io/epochs/{epoch}'

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/epochs/{epoch}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/epochs/{epoch}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/epochs/{epoch}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/epochs/{epoch}')
request = Net::HTTP::Get.new(uri)

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

{
  "epoch": 641,
  "start_time": 1783080000,
  "end_time": 1783512000,
  "first_block_time": 1783080001,
  "last_block_time": 1783421965,
  "block_count": 21600,
  "tx_count": 250000,
  "output": "1000000000000",
  "fees": "100000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Genesis

Genesis operations.

Get genesis configuration

GET

https://ada-blockfrost.nownodes.io/genesis

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the genesis configuration parameters that were used to bootstrap the Cardano blockchain.

Response

200OK

HTTP 200 response for getGenesis.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get genesis configuration

curl -X GET 'https://ada-blockfrost.nownodes.io/genesis'

const response = await fetch('https://ada-blockfrost.nownodes.io/genesis', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/genesis')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/genesis')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/genesis', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/genesis";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/genesis', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/genesis')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/genesis')
request = Net::HTTP::Get.new(uri)

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

{
  "active_slots_coefficient": 0.05,
  "update_quorum": 5,
  "max_lovelace_supply": "45000000000000000",
  "network_magic": 764824073,
  "epoch_length": 432000,
  "system_start": 1506203091,
  "slots_per_kes_period": 129600,
  "slot_length": 1
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Governance

Governance operations.

Get the constitutional committee information

GET

https://ada-blockfrost.nownodes.io/governance/committee

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about the current constitutional committee, including its quorum threshold and the list of committee members with their credentials and status.

Response

200OK

HTTP 200 response for getGovernanceCommittee.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get the constitutional committee information

curl -X GET 'https://ada-blockfrost.nownodes.io/governance/committee'

const response = await fetch('https://ada-blockfrost.nownodes.io/governance/committee', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/governance/committee')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/governance/committee')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/governance/committee', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/governance/committee";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/governance/committee', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/governance/committee')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/governance/committee')
request = Net::HTTP::Get.new(uri)

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

[]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Blockfrost

Blockfrost operations.

Get the constitutional committee votes

GET

https://ada-blockfrost.nownodes.io/governance/committee/votes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of all votes cast by constitutional committee members on governance actions. Each entry represents a single vote by a committee member's hot credential on a specific governance proposal.

Response

200OK

HTTP 200 response for getGovernanceCommitteeVotes.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get the constitutional committee votes

curl -X GET 'https://ada-blockfrost.nownodes.io/governance/committee/votes'

const response = await fetch('https://ada-blockfrost.nownodes.io/governance/committee/votes', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/governance/committee/votes')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/governance/committee/votes')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/governance/committee/votes', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/governance/committee/votes";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/governance/committee/votes', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/governance/committee/votes')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/governance/committee/votes')
request = Net::HTTP::Get.new(uri)

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

[]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Metadata

Metadata operations.

List all transaction metadata labels

GET

https://ada-blockfrost.nownodes.io/metadata/txs/labels

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of all distinct metadata labels that have been used in transactions on the Cardano blockchain.

Parameters

pageinteger1query

Page number. Defaults to 1.

countinteger<= 100100query

Results per page. Max 100.

orderstringascdescascquery

Sort order.

Response

200OK

HTTP 200 response for getMetadataLabels.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

List all transaction metadata labels

curl -X GET 'https://ada-blockfrost.nownodes.io/metadata/txs/labels'

const response = await fetch('https://ada-blockfrost.nownodes.io/metadata/txs/labels', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/metadata/txs/labels')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/metadata/txs/labels')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/metadata/txs/labels', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/metadata/txs/labels";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/metadata/txs/labels', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/metadata/txs/labels')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/metadata/txs/labels')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "label": "721",
    "cip10": "Cardano NFT metadata",
    "count": "1"
  }
]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get metadata content by label

GET

https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns transaction metadata entries associated with the specified label.

Parameters

labelstringrequiredpath

Numeric metadata label to query.

pageinteger1query

Page number. Defaults to 1.

countinteger<= 100100query

Results per page. Max 100.

orderstringascdescascquery

Sort order.

Response

200OK

HTTP 200 response for getMetadataByLabel.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get metadata content by label

curl -X GET 'https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}'

const response = await fetch('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "label": "721",
    "cip10": "Cardano NFT metadata",
    "count": "1"
  }
]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get transaction metadata CBOR by label

GET

https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}/cbor

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of transaction metadata entries for the specified numeric label with the metadata content provided in both raw CBOR hex encoding and a secondary hex metadata field. This endpoint is useful when the client needs the exact on-chain byte representation rather than a potentially lossy JSON conversion. Common well-known labels include 721 (CIP-25 NFT metadata), 674 (CIP-20 transaction messages), and 1967 (nut.link oracle feeds). Labels are registered under the CIP-10 standard.

Parameters

labelstringrequiredpath

Numeric metadata label to query. Labels are unsigned integers that serve as top-level keys in the Cardano transaction metadata map (auxiliary data). They partition metadata into logical namespaces so that different applications can coexist within the same transaction without collision.

countinteger<= 100100query

Maximum number of metadata entries to return per page. Defaults to 100; cannot exceed 100.

pageinteger1query

Page number for pagination. The first page is 1.

orderstringascdescascquery

Sort order of the results by transaction inclusion time. "asc" returns oldest transactions first; "desc" returns newest first.

Response

200OK

HTTP 200 response for getMetadataByLabelCbor.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

404Not Found

No metadata found for the given label.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get transaction metadata CBOR by label

curl -X GET 'https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}/cbor'

const response = await fetch('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}/cbor', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}/cbor')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}/cbor')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}/cbor', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}/cbor";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}/cbor', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}/cbor')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/metadata/txs/labels/{label}/cbor')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "label": "721",
    "cip10": "Cardano NFT metadata",
    "count": "1"
  }
]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

{
  "status_code": 404,
  "error": "Not Found",
  "message": "The requested component has not been found."
}

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Network

Network operations.

Get network information

GET

https://ada-blockfrost.nownodes.io/network

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns detailed information about the Cardano network's ADA supply breakdown (maximum, total, circulating, locked, treasury, and reserves) and the current staking statistics (live and active stake).

Response

200OK

HTTP 200 response for getNetwork.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get network information

curl -X GET 'https://ada-blockfrost.nownodes.io/network'

const response = await fetch('https://ada-blockfrost.nownodes.io/network', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/network')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/network')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/network', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/network";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/network', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/network')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/network')
request = Net::HTTP::Get.new(uri)

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

{
  "supply": {
    "max": "45000000000000000",
    "total": "38451959434790517",
    "circulating": "33559039338616223",
    "locked": "192931364922692",
    "treasury": "1638585447047618",
    "reserves": "6548040565209483"
  },
  "stake": {
    "live": "33751591743357276",
    "active": "21513392623540974"
  }
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get Cardano network eras

GET

https://ada-blockfrost.nownodes.io/network/eras

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of all Cardano ledger eras (Byron, Shelley, Allegra, Mary, Alonzo, Babbage, Conway) with their start and end boundaries expressed in epoch and slot numbers.

Response

200OK

HTTP 200 response for getNetworkEras.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get Cardano network eras

curl -X GET 'https://ada-blockfrost.nownodes.io/network/eras'

const response = await fetch('https://ada-blockfrost.nownodes.io/network/eras', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/network/eras')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/network/eras')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/network/eras', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/network/eras";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/network/eras', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/network/eras')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/network/eras')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "era": "conway",
    "start": {
      "time": 1713059199,
      "slot": 133660800,
      "epoch": 475
    },
    "end": null
  }
]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Pools

Pools operations.

List active stake pools

GET

https://ada-blockfrost.nownodes.io/pools

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of Bech32-encoded IDs of all currently registered and active stake pools on the Cardano network.

Parameters

pageinteger1query

Page number. Defaults to 1.

countinteger<= 100100query

Results per page. Max 100.

orderstringascdescascquery

Sort order.

Response

200OK

HTTP 200 response for getPools.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

List active stake pools

curl -X GET 'https://ada-blockfrost.nownodes.io/pools'

const response = await fetch('https://ada-blockfrost.nownodes.io/pools', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/pools', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/pools";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/pools', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
    "hex": "79c4d4fe108f480fee98f307adae12571df2959651f833b195139a25"
  }
]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

List retired stake pools

GET

https://ada-blockfrost.nownodes.io/pools/retired

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of all stake pools that have completed their retirement.

Parameters

pageinteger1query

Page number. Defaults to 1.

countinteger<= 100100query

Results per page. Max 100.

orderstringascdescascquery

Sort order.

Response

200OK

HTTP 200 response for getRetiredPools.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

List retired stake pools

curl -X GET 'https://ada-blockfrost.nownodes.io/pools/retired'

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/retired', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/retired')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/retired')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/retired', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/pools/retired";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/retired', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/retired')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/retired')
request = Net::HTTP::Get.new(uri)

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

{
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "hex": "79c4d4fe108f480fee98f307adae12571df2959651f833b195139a25",
  "vrf_key": "vrf_vk1vxkyne4ftwjz4vlla756mlfqrmzwx35mkhk7d993njzmceksfp2q3kp8d4",
  "blocks_minted": 100,
  "live_stake": "1000000000000",
  "live_saturation": 0.01,
  "active_stake": "900000000000",
  "declared_pledge": "500000000000",
  "margin_cost": 0.03,
  "fixed_cost": "340000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

List retiring stake pools

GET

https://ada-blockfrost.nownodes.io/pools/retiring

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a list of stake pools that are scheduled to retire in a future epoch.

Response

200OK

HTTP 200 response for getRetiringPools.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

List retiring stake pools

curl -X GET 'https://ada-blockfrost.nownodes.io/pools/retiring'

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/retiring', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/retiring')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/retiring')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/retiring', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/pools/retiring";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/retiring', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/retiring')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/retiring')
request = Net::HTTP::Get.new(uri)

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

{
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "hex": "79c4d4fe108f480fee98f307adae12571df2959651f833b195139a25",
  "vrf_key": "vrf_vk1vxkyne4ftwjz4vlla756mlfqrmzwx35mkhk7d993njzmceksfp2q3kp8d4",
  "blocks_minted": 100,
  "live_stake": "1000000000000",
  "live_saturation": 0.01,
  "active_stake": "900000000000",
  "declared_pledge": "500000000000",
  "margin_cost": 0.03,
  "fixed_cost": "340000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get stake pool metadata

GET

https://ada-blockfrost.nownodes.io/pools/{pool_id}/metadata

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns off-chain metadata registered by the specified stake pool, such as name, ticker, description, and homepage URL.

Parameters

pool_idstringrequiredpath

Bech32 or hex-encoded stake pool ID.

Response

200OK

HTTP 200 response for getPoolMetadata.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get stake pool metadata

curl -X GET 'https://ada-blockfrost.nownodes.io/pools/{pool_id}/metadata'

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/metadata', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/metadata')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/{pool_id}/metadata')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/metadata', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/pools/{pool_id}/metadata";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/metadata', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/{pool_id}/metadata')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/metadata')
request = Net::HTTP::Get.new(uri)

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

{
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "hex": "79c4d4fe108f480fee98f307adae12571df2959651f833b195139a25",
  "vrf_key": "vrf_vk1vxkyne4ftwjz4vlla756mlfqrmzwx35mkhk7d993njzmceksfp2q3kp8d4",
  "blocks_minted": 100,
  "live_stake": "1000000000000",
  "live_saturation": 0.01,
  "active_stake": "900000000000",
  "declared_pledge": "500000000000",
  "margin_cost": 0.03,
  "fixed_cost": "340000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get stake pool relays

GET

https://ada-blockfrost.nownodes.io/pools/{pool_id}/relays

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the list of network relay endpoints registered by the specified stake pool.

Parameters

pool_idstringrequiredpath

Bech32 or hex-encoded stake pool ID.

Response

200OK

HTTP 200 response for getPoolRelays.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get stake pool relays

curl -X GET 'https://ada-blockfrost.nownodes.io/pools/{pool_id}/relays'

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/relays', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/relays')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/{pool_id}/relays')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/relays', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/pools/{pool_id}/relays";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/relays', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/{pool_id}/relays')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/relays')
request = Net::HTTP::Get.new(uri)

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

{
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "hex": "79c4d4fe108f480fee98f307adae12571df2959651f833b195139a25",
  "vrf_key": "vrf_vk1vxkyne4ftwjz4vlla756mlfqrmzwx35mkhk7d993njzmceksfp2q3kp8d4",
  "blocks_minted": 100,
  "live_stake": "1000000000000",
  "live_saturation": 0.01,
  "active_stake": "900000000000",
  "declared_pledge": "500000000000",
  "margin_cost": 0.03,
  "fixed_cost": "340000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get stake pool delegators

GET

https://ada-blockfrost.nownodes.io/pools/{pool_id}/delegators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of addresses currently delegating to the specified stake pool.

Parameters

pool_idstringrequiredpath

Bech32 or hex-encoded stake pool ID.

pageinteger1query

Page number. Defaults to 1.

countinteger<= 100100query

Results per page. Max 100.

orderstringascdescascquery

Sort order.

Response

200OK

HTTP 200 response for getPoolDelegators.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get stake pool delegators

curl -X GET 'https://ada-blockfrost.nownodes.io/pools/{pool_id}/delegators'

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/delegators', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/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://ada-blockfrost.nownodes.io/pools/{pool_id}/delegators')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/delegators', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/pools/{pool_id}/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://ada-blockfrost.nownodes.io/pools/{pool_id}/delegators', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/{pool_id}/delegators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/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)

{
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "hex": "79c4d4fe108f480fee98f307adae12571df2959651f833b195139a25",
  "vrf_key": "vrf_vk1vxkyne4ftwjz4vlla756mlfqrmzwx35mkhk7d993njzmceksfp2q3kp8d4",
  "blocks_minted": 100,
  "live_stake": "1000000000000",
  "live_saturation": 0.01,
  "active_stake": "900000000000",
  "declared_pledge": "500000000000",
  "margin_cost": 0.03,
  "fixed_cost": "340000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get stake pool blocks

GET

https://ada-blockfrost.nownodes.io/pools/{pool_id}/blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of block hashes minted by the specified stake pool.

Parameters

pool_idstringrequiredpath

Bech32 or hex-encoded stake pool ID.

pageinteger1query

Page number. Defaults to 1.

countinteger<= 100100query

Results per page. Max 100.

orderstringascdescascquery

Sort order.

Response

200OK

HTTP 200 response for getPoolBlocks.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get stake pool blocks

curl -X GET 'https://ada-blockfrost.nownodes.io/pools/{pool_id}/blocks'

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/blocks', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/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://ada-blockfrost.nownodes.io/pools/{pool_id}/blocks')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/blocks', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/pools/{pool_id}/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://ada-blockfrost.nownodes.io/pools/{pool_id}/blocks', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/{pool_id}/blocks')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/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)

{
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "hex": "79c4d4fe108f480fee98f307adae12571df2959651f833b195139a25",
  "vrf_key": "vrf_vk1vxkyne4ftwjz4vlla756mlfqrmzwx35mkhk7d993njzmceksfp2q3kp8d4",
  "blocks_minted": 100,
  "live_stake": "1000000000000",
  "live_saturation": 0.01,
  "active_stake": "900000000000",
  "declared_pledge": "500000000000",
  "margin_cost": 0.03,
  "fixed_cost": "340000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get stake pool update history

GET

https://ada-blockfrost.nownodes.io/pools/{pool_id}/updates

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the full history of registration and update certificates submitted for the specified stake pool.

Parameters

pool_idstringrequiredpath

Bech32 or hex-encoded stake pool ID.

Response

200OK

HTTP 200 response for getPoolUpdates.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get stake pool update history

curl -X GET 'https://ada-blockfrost.nownodes.io/pools/{pool_id}/updates'

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/updates', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/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://ada-blockfrost.nownodes.io/pools/{pool_id}/updates')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/updates', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/pools/{pool_id}/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://ada-blockfrost.nownodes.io/pools/{pool_id}/updates', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/{pool_id}/updates')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/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)

{
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "hex": "79c4d4fe108f480fee98f307adae12571df2959651f833b195139a25",
  "vrf_key": "vrf_vk1vxkyne4ftwjz4vlla756mlfqrmzwx35mkhk7d993njzmceksfp2q3kp8d4",
  "blocks_minted": 100,
  "live_stake": "1000000000000",
  "live_saturation": 0.01,
  "active_stake": "900000000000",
  "declared_pledge": "500000000000",
  "margin_cost": 0.03,
  "fixed_cost": "340000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

List stake pools with extended information

GET

https://ada-blockfrost.nownodes.io/pools/extended

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of all registered stake pools enriched with live and active stake amounts, saturation level, block minting count, pledge, cost parameters, and off-chain metadata.

Parameters

pageinteger1query

Page number for pagination. Defaults to 1.

countinteger<= 100100query

Maximum number of results per page. Defaults to 100; cannot exceed 100.

orderstringascdescascquery

Sort order of the results.

Response

200OK

HTTP 200 response for getPoolsExtended.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

List stake pools with extended information

curl -X GET 'https://ada-blockfrost.nownodes.io/pools/extended'

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/extended', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/extended')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/extended')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/extended', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/pools/extended";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/extended', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/extended')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/extended')
request = Net::HTTP::Get.new(uri)

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

{
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "hex": "79c4d4fe108f480fee98f307adae12571df2959651f833b195139a25",
  "vrf_key": "vrf_vk1vxkyne4ftwjz4vlla756mlfqrmzwx35mkhk7d993njzmceksfp2q3kp8d4",
  "blocks_minted": 100,
  "live_stake": "1000000000000",
  "live_saturation": 0.01,
  "active_stake": "900000000000",
  "declared_pledge": "500000000000",
  "margin_cost": 0.03,
  "fixed_cost": "340000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get stake pool details

GET

https://ada-blockfrost.nownodes.io/pools/{pool_id}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns comprehensive on-chain details for a specific stake pool including live and active stake, saturation, delegator count, pledge information, cost parameters, VRF key, reward account, owner addresses, and full registration and retirement transaction history.

Parameters

pool_idstringrequiredpath

Bech32-encoded or hex-encoded stake pool identifier.

Response

200OK

HTTP 200 response for getPool.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

404Not Found

Pool not found.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get stake pool details

curl -X GET 'https://ada-blockfrost.nownodes.io/pools/{pool_id}'

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_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://ada-blockfrost.nownodes.io/pools/{pool_id}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/pools/{pool_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://ada-blockfrost.nownodes.io/pools/{pool_id}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/{pool_id}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_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)

{
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "hex": "79c4d4fe108f480fee98f307adae12571df2959651f833b195139a25",
  "vrf_key": "vrf_vk1vxkyne4ftwjz4vlla756mlfqrmzwx35mkhk7d993njzmceksfp2q3kp8d4",
  "blocks_minted": 100,
  "live_stake": "1000000000000",
  "live_saturation": 0.01,
  "active_stake": "900000000000",
  "declared_pledge": "500000000000",
  "margin_cost": 0.03,
  "fixed_cost": "340000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get stake pool epoch history

GET

https://ada-blockfrost.nownodes.io/pools/{pool_id}/history

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a chronological list of per-epoch performance data for the specified stake pool, including blocks minted, active stake, relative size, delegator count, earned rewards, and collected fees.

Parameters

pool_idstringrequiredpath

Bech32 or hex-encoded stake pool identifier.

Response

200OK

HTTP 200 response for getPoolHistory.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

404Not Found

Pool not found.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get stake pool epoch history

curl -X GET 'https://ada-blockfrost.nownodes.io/pools/{pool_id}/history'

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/history', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/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://ada-blockfrost.nownodes.io/pools/{pool_id}/history')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/pools/{pool_id}/history', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/pools/{pool_id}/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://ada-blockfrost.nownodes.io/pools/{pool_id}/history', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/pools/{pool_id}/history')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/pools/{pool_id}/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)

{
  "pool_id": "pool108zdflss3ayqlm5c7vr6mtqj2uwl99vk28ur8dv4zswdzt6yauc",
  "hex": "79c4d4fe108f480fee98f307adae12571df2959651f833b195139a25",
  "vrf_key": "vrf_vk1vxkyne4ftwjz4vlla756mlfqrmzwx35mkhk7d993njzmceksfp2q3kp8d4",
  "blocks_minted": 100,
  "live_stake": "1000000000000",
  "live_saturation": 0.01,
  "active_stake": "900000000000",
  "declared_pledge": "500000000000",
  "margin_cost": 0.03,
  "fixed_cost": "340000000"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Scripts

Scripts operations.

List all scripts

GET

https://ada-blockfrost.nownodes.io/scripts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of all script hashes deployed on the Cardano blockchain.

Parameters

pageinteger1query

Page number. Defaults to 1.

countinteger<= 100100query

Results per page. Max 100.

orderstringascdescascquery

Sort order.

Response

200OK

HTTP 200 response for listScripts.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

List all scripts

curl -X GET 'https://ada-blockfrost.nownodes.io/scripts'

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/scripts";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts')
request = Net::HTTP::Get.new(uri)

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

[
  {
    "script_hash": "f9b162ea9529e639a083595294006a833473883a75d6df1e4c22dd4f504f4c4c5f4d414e41474552",
    "type": "plutusV2",
    "serialised_size": 1234
  }
]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get script information

GET

https://ada-blockfrost.nownodes.io/scripts/{script}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns detailed information about a specific script including its type and serialised size.

Parameters

scriptstringrequiredpath

Script hash identifier.

Response

200OK

HTTP 200 response for getScript.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get script information

curl -X GET 'https://ada-blockfrost.nownodes.io/scripts/{script}'

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/{script}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts/{script}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/scripts/{script}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts/{script}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/{script}')
request = Net::HTTP::Get.new(uri)

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

{
  "script_hash": "f9b162ea9529e639a083595294006a833473883a75d6df1e4c22dd4f504f4c4c5f4d414e41474552",
  "type": "plutusV2",
  "serialised_size": 1234
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get script JSON representation

GET

https://ada-blockfrost.nownodes.io/scripts/{script}/json

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the JSON representation of a native (timelock) script. For Plutus scripts the response may contain a wrapper indicating the Plutus version.

Parameters

scriptstringrequiredpath

Script hash identifier.

Response

200OK

HTTP 200 response for getScriptJson.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get script JSON representation

curl -X GET 'https://ada-blockfrost.nownodes.io/scripts/{script}/json'

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}/json', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/{script}/json')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts/{script}/json')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}/json', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/scripts/{script}/json";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}/json', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts/{script}/json')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/{script}/json')
request = Net::HTTP::Get.new(uri)

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

{
  "script_hash": "f9b162ea9529e639a083595294006a833473883a75d6df1e4c22dd4f504f4c4c5f4d414e41474552",
  "type": "plutusV2",
  "serialised_size": 1234
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get script CBOR representation

GET

https://ada-blockfrost.nownodes.io/scripts/{script}/cbor

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the hex-encoded CBOR serialisation of the script.

Parameters

scriptstringrequiredpath

Script hash identifier.

Response

200OK

HTTP 200 response for getScriptCbor.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get script CBOR representation

curl -X GET 'https://ada-blockfrost.nownodes.io/scripts/{script}/cbor'

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}/cbor', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/{script}/cbor')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts/{script}/cbor')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}/cbor', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/scripts/{script}/cbor";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}/cbor', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts/{script}/cbor')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/{script}/cbor')
request = Net::HTTP::Get.new(uri)

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

{
  "script_hash": "f9b162ea9529e639a083595294006a833473883a75d6df1e4c22dd4f504f4c4c5f4d414e41474552",
  "type": "plutusV2",
  "serialised_size": 1234
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get redeemers for script

GET

https://ada-blockfrost.nownodes.io/scripts/{script}/redeemers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a paginated list of all redeemers that have been used with the specified script across all transactions.

Parameters

scriptstringrequiredpath

Script hash identifier.

pageinteger1query

Page number.

countinteger<= 100100query

Results per page. Max 100.

orderstringascdescascquery

Sort order.

Response

200OK

HTTP 200 response for getScriptRedeemers.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get redeemers for script

curl -X GET 'https://ada-blockfrost.nownodes.io/scripts/{script}/redeemers'

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}/redeemers', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/{script}/redeemers')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts/{script}/redeemers')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}/redeemers', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/scripts/{script}/redeemers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/{script}/redeemers', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts/{script}/redeemers')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/{script}/redeemers')
request = Net::HTTP::Get.new(uri)

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

{
  "script_hash": "f9b162ea9529e639a083595294006a833473883a75d6df1e4c22dd4f504f4c4c5f4d414e41474552",
  "type": "plutusV2",
  "serialised_size": 1234
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get CBOR datum for script

GET

https://ada-blockfrost.nownodes.io/scripts/datum/{script}/cbor

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the hex-encoded CBOR representation of the datum associated with the given datum hash.

Parameters

scriptstringrequiredpath

Datum hash identifier.

Response

200OK

HTTP 200 response for getScriptDatumCbor.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get CBOR datum for script

curl -X GET 'https://ada-blockfrost.nownodes.io/scripts/datum/{script}/cbor'

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/datum/{script}/cbor', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/datum/{script}/cbor')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts/datum/{script}/cbor')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/datum/{script}/cbor', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/scripts/datum/{script}/cbor";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/datum/{script}/cbor', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts/datum/{script}/cbor')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/datum/{script}/cbor')
request = Net::HTTP::Get.new(uri)

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

{
  "script_hash": "f9b162ea9529e639a083595294006a833473883a75d6df1e4c22dd4f504f4c4c5f4d414e41474552",
  "type": "plutusV2",
  "serialised_size": 1234
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get datum value by hash

GET

https://ada-blockfrost.nownodes.io/scripts/datum/{datum_hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the full JSON representation of a Plutus datum identified by its Blake2b-256 hash. Datums are structured data values attached to transaction outputs and consumed by Plutus validator scripts. The datum hash is recorded on-chain inside the UTXO, while the actual datum content is supplied via the transaction witness set or embedded as an inline datum (CIP-32). The returned JSON follows the canonical Plutus JSON schema where data is expressed through constructors, fields, integers, byte strings, lists, and maps.

Parameters

datum_hashstringrequiredpath

Blake2b-256 hash of the datum to retrieve, encoded as a 64-character lowercase hexadecimal string. This hash is computed over the CBOR-serialised datum and is stored on-chain in the UTXO that references it.

Response

200OK

HTTP 200 response for getScriptDatum.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

404Not Found

No datum found for the given hash.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get datum value by hash

curl -X GET 'https://ada-blockfrost.nownodes.io/scripts/datum/{datum_hash}'

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/datum/{datum_hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/datum/{datum_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://ada-blockfrost.nownodes.io/scripts/datum/{datum_hash}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/scripts/datum/{datum_hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/scripts/datum/{datum_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://ada-blockfrost.nownodes.io/scripts/datum/{datum_hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/scripts/datum/{datum_hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/scripts/datum/{datum_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)

{
  "script_hash": "f9b162ea9529e639a083595294006a833473883a75d6df1e4c22dd4f504f4c4c5f4d414e41474552",
  "type": "plutusV2",
  "serialised_size": 1234
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

{
  "status_code": 404,
  "error": "Not Found",
  "message": "The requested component has not been found."
}

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Transactions

Transactions operations.

Get transaction info

GET

https://ada-blockfrost.nownodes.io/txs/{hash}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns full details of a transaction identified by its hash.

Parameters

hashstringrequiredpath

The unique transaction hash identifier (64 hexadecimal characters)

Response

200OK

HTTP 200 response for getTransaction.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get transaction info

curl -X GET 'https://ada-blockfrost.nownodes.io/txs/{hash}'

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{hash}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{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://ada-blockfrost.nownodes.io/txs/{hash}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{hash}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/txs/{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://ada-blockfrost.nownodes.io/txs/{hash}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{hash}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{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)

{
  "hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "block": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "block_height": 13646894,
  "block_time": 1783421965,
  "slot": 191855674,
  "index": 0,
  "output_amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "fees": "413224",
  "deposit": "0",
  "size": 1010,
  "invalid_before": "191855602",
  "invalid_hereafter": "191856801",
  "utxo_count": 6,
  "withdrawal_count": 0,
  "redeemer_count": 2,
  "valid_contract": true,
  "treasury_donation": "0"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get transaction stakes

GET

https://ada-blockfrost.nownodes.io/txs/{tx}/stakes

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all stake key registration and deregistration certificates included in the transaction.

Parameters

txstringrequiredpath

Transaction hash (hex).

Response

200OK

HTTP 200 response for getTransactionStakes.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get transaction stakes

curl -X GET 'https://ada-blockfrost.nownodes.io/txs/{tx}/stakes'

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/stakes', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/stakes')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/stakes')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/stakes', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/txs/{tx}/stakes";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/stakes', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/stakes')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/stakes')
request = Net::HTTP::Get.new(uri)

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

{
  "hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "block": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "block_height": 13646894,
  "block_time": 1783421965,
  "slot": 191855674,
  "index": 0,
  "output_amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "fees": "413224",
  "deposit": "0",
  "size": 1010,
  "invalid_before": "191855602",
  "invalid_hereafter": "191856801",
  "utxo_count": 6,
  "withdrawal_count": 0,
  "redeemer_count": 2,
  "valid_contract": true,
  "treasury_donation": "0"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get transaction delegations

GET

https://ada-blockfrost.nownodes.io/txs/{tx}/delegations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns delegation certificates included in the transaction.

Parameters

txstringrequiredpath

Transaction hash (hex).

Response

200OK

HTTP 200 response for getTransactionDelegations.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get transaction delegations

curl -X GET 'https://ada-blockfrost.nownodes.io/txs/{tx}/delegations'

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/delegations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/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://ada-blockfrost.nownodes.io/txs/{tx}/delegations')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/delegations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/txs/{tx}/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://ada-blockfrost.nownodes.io/txs/{tx}/delegations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/delegations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/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)

{
  "hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "block": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "block_height": 13646894,
  "block_time": 1783421965,
  "slot": 191855674,
  "index": 0,
  "output_amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "fees": "413224",
  "deposit": "0",
  "size": 1010,
  "invalid_before": "191855602",
  "invalid_hereafter": "191856801",
  "utxo_count": 6,
  "withdrawal_count": 0,
  "redeemer_count": 2,
  "valid_contract": true,
  "treasury_donation": "0"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get transaction withdrawals

GET

https://ada-blockfrost.nownodes.io/txs/{tx}/withdrawals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all reward account withdrawals included in the transaction.

Parameters

txstringrequiredpath

Transaction hash (hex).

Response

200OK

HTTP 200 response for getTransactionWithdrawals.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get transaction withdrawals

curl -X GET 'https://ada-blockfrost.nownodes.io/txs/{tx}/withdrawals'

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/withdrawals', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/withdrawals')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/withdrawals')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/withdrawals', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/txs/{tx}/withdrawals";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/withdrawals', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/withdrawals')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/withdrawals')
request = Net::HTTP::Get.new(uri)

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

{
  "hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "block": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "block_height": 13646894,
  "block_time": 1783421965,
  "slot": 191855674,
  "index": 0,
  "output_amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "fees": "413224",
  "deposit": "0",
  "size": 1010,
  "invalid_before": "191855602",
  "invalid_hereafter": "191856801",
  "utxo_count": 6,
  "withdrawal_count": 0,
  "redeemer_count": 2,
  "valid_contract": true,
  "treasury_donation": "0"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get MIRs in transaction

GET

https://ada-blockfrost.nownodes.io/txs/{tx}/mirs

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all Move Instantaneous Reward (MIR) certificates included in the transaction.

Parameters

txstringrequiredpath

Transaction hash (hex).

Response

200OK

HTTP 200 response for getTransactionMirs.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get MIRs in transaction

curl -X GET 'https://ada-blockfrost.nownodes.io/txs/{tx}/mirs'

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/mirs', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/mirs')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/mirs')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/mirs', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/txs/{tx}/mirs";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/mirs', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/mirs')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/mirs')
request = Net::HTTP::Get.new(uri)

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

{
  "hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "block": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "block_height": 13646894,
  "block_time": 1783421965,
  "slot": 191855674,
  "index": 0,
  "output_amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "fees": "413224",
  "deposit": "0",
  "size": 1010,
  "invalid_before": "191855602",
  "invalid_hereafter": "191856801",
  "utxo_count": 6,
  "withdrawal_count": 0,
  "redeemer_count": 2,
  "valid_contract": true,
  "treasury_donation": "0"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get pool updates in transaction

GET

https://ada-blockfrost.nownodes.io/txs/{tx}/pool_updates

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns pool registration or parameter-update certificates included in the transaction.

Parameters

txstringrequiredpath

Transaction hash (hex).

Response

200OK

HTTP 200 response for getTransactionPoolUpdates.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get pool updates in transaction

curl -X GET 'https://ada-blockfrost.nownodes.io/txs/{tx}/pool_updates'

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_updates', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_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://ada-blockfrost.nownodes.io/txs/{tx}/pool_updates')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_updates', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/txs/{tx}/pool_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://ada-blockfrost.nownodes.io/txs/{tx}/pool_updates', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_updates')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_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)

{
  "hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "block": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "block_height": 13646894,
  "block_time": 1783421965,
  "slot": 191855674,
  "index": 0,
  "output_amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "fees": "413224",
  "deposit": "0",
  "size": 1010,
  "invalid_before": "191855602",
  "invalid_hereafter": "191856801",
  "utxo_count": 6,
  "withdrawal_count": 0,
  "redeemer_count": 2,
  "valid_contract": true,
  "treasury_donation": "0"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get pool retirements in transaction

GET

https://ada-blockfrost.nownodes.io/txs/{tx}/pool_retires

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns pool retirement certificates included in the transaction.

Parameters

txstringrequiredpath

Transaction hash (hex).

Response

200OK

HTTP 200 response for getTransactionPoolRetires.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get pool retirements in transaction

curl -X GET 'https://ada-blockfrost.nownodes.io/txs/{tx}/pool_retires'

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_retires', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_retires')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_retires')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_retires', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/txs/{tx}/pool_retires";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_retires', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_retires')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/pool_retires')
request = Net::HTTP::Get.new(uri)

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

{
  "hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "block": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "block_height": 13646894,
  "block_time": 1783421965,
  "slot": 191855674,
  "index": 0,
  "output_amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "fees": "413224",
  "deposit": "0",
  "size": 1010,
  "invalid_before": "191855602",
  "invalid_hereafter": "191856801",
  "utxo_count": 6,
  "withdrawal_count": 0,
  "redeemer_count": 2,
  "valid_contract": true,
  "treasury_donation": "0"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get transaction metadata

GET

https://ada-blockfrost.nownodes.io/txs/{tx}/metadata

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns JSON metadata attached to the transaction, grouped by label.

Parameters

txstringrequiredpath

Transaction hash (hex).

Response

200OK

HTTP 200 response for getTransactionMetadata.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get transaction metadata

curl -X GET 'https://ada-blockfrost.nownodes.io/txs/{tx}/metadata'

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/txs/{tx}/metadata";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata')
request = Net::HTTP::Get.new(uri)

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

{
  "hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "block": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "block_height": 13646894,
  "block_time": 1783421965,
  "slot": 191855674,
  "index": 0,
  "output_amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "fees": "413224",
  "deposit": "0",
  "size": 1010,
  "invalid_before": "191855602",
  "invalid_hereafter": "191856801",
  "utxo_count": 6,
  "withdrawal_count": 0,
  "redeemer_count": 2,
  "valid_contract": true,
  "treasury_donation": "0"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get transaction metadata in CBOR

GET

https://ada-blockfrost.nownodes.io/txs/{tx}/metadata/cbor

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the hex-encoded CBOR serialisation of the metadata attached to the transaction.

Parameters

txstringrequiredpath

Transaction hash (hex).

Response

200OK

HTTP 200 response for getTransactionMetadataCbor.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get transaction metadata in CBOR

curl -X GET 'https://ada-blockfrost.nownodes.io/txs/{tx}/metadata/cbor'

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata/cbor', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata/cbor')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata/cbor')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata/cbor', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/txs/{tx}/metadata/cbor";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata/cbor', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata/cbor')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/metadata/cbor')
request = Net::HTTP::Get.new(uri)

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

{
  "hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "block": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "block_height": 13646894,
  "block_time": 1783421965,
  "slot": 191855674,
  "index": 0,
  "output_amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "fees": "413224",
  "deposit": "0",
  "size": 1010,
  "invalid_before": "191855602",
  "invalid_hereafter": "191856801",
  "utxo_count": 6,
  "withdrawal_count": 0,
  "redeemer_count": 2,
  "valid_contract": true,
  "treasury_donation": "0"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get redeemers for transaction

GET

https://ada-blockfrost.nownodes.io/txs/{tx}/redeemers

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all Plutus script redeemers included in the specified transaction.

Parameters

txstringrequiredpath

Transaction hash (hex).

Response

200OK

HTTP 200 response for getTransactionRedeemers.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get redeemers for transaction

curl -X GET 'https://ada-blockfrost.nownodes.io/txs/{tx}/redeemers'

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/redeemers', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/redeemers')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/redeemers')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/redeemers', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/txs/{tx}/redeemers";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/redeemers', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/redeemers')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/redeemers')
request = Net::HTTP::Get.new(uri)

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

{
  "hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "block": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "block_height": 13646894,
  "block_time": 1783421965,
  "slot": 191855674,
  "index": 0,
  "output_amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "fees": "413224",
  "deposit": "0",
  "size": 1010,
  "invalid_before": "191855602",
  "invalid_hereafter": "191856801",
  "utxo_count": 6,
  "withdrawal_count": 0,
  "redeemer_count": 2,
  "valid_contract": true,
  "treasury_donation": "0"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Get transaction UTXOs

GET

https://ada-blockfrost.nownodes.io/txs/{tx}/utxos

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the full input and output UTXO breakdown of a specific transaction. Each input shows the source address, value, and originating transaction reference; each output shows the destination address, value, datum information, and whether the output has been consumed by a subsequent transaction.

Parameters

txstringrequiredpath

Blake2b-256 hex-encoded hash of the transaction to query.

Response

200OK

HTTP 200 response for getTransactionUtxos.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

404Not Found

Transaction not found.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Get transaction UTXOs

curl -X GET 'https://ada-blockfrost.nownodes.io/txs/{tx}/utxos'

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/utxos', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/utxos')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/utxos')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/utxos', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/txs/{tx}/utxos";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ada-blockfrost.nownodes.io/txs/{tx}/utxos', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/txs/{tx}/utxos')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/txs/{tx}/utxos')
request = Net::HTTP::Get.new(uri)

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

{
  "hash": "04cba8a56386ee2a23563e8f05b6e80c7074b56b099945abaecae8040c3b1650",
  "block": "9945cd69ca8e6bcf2e5f9a14742be0c051bf9dd916f0bb0b00ab39977b140d53",
  "block_height": 13646894,
  "block_time": 1783421965,
  "slot": 191855674,
  "index": 0,
  "output_amount": [
    {
      "unit": "lovelace",
      "quantity": "94923541"
    },
    {
      "unit": "533bb94a8850ee3ccbe483106489399112b74c905342cb1792a797a0494e4459",
      "quantity": "221350388"
    }
  ],
  "fees": "413224",
  "deposit": "0",
  "size": 1010,
  "invalid_before": "191855602",
  "invalid_hereafter": "191856801",
  "utxo_count": 6,
  "withdrawal_count": 0,
  "redeemer_count": 2,
  "valid_contract": true,
  "treasury_donation": "0"
}

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Utils

Utils operations.

Generate address from xpub

GET

https://ada-blockfrost.nownodes.io/utils/addresses/xpub/{address}/{role}/{index}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Derives a Cardano Shelley payment address from an extended public key (xpub) using the specified role (external or internal/change) and address derivation index.

Parameters

addressstringrequiredpath

Extended public key (xpub) encoded in hex or base58. This is the account-level public key from which child addresses are derived.

roleinteger01requiredpath

BIP-44 role index. 0 = external (receiving) address, 1 = internal (change) address.

indexinteger>= 0requiredpath

Zero-based derivation index of the address to generate.

Response

200OK

HTTP 200 response for generateAddressFromXpub.

400Bad Request

Bad Request. The request is malformed or contains invalid parameters.

401Unauthorized

Unauthorized: API key is present but rejected by the NOWNodes gateway.

404Not Found

Extended public key not found or invalid.

422Unprocessable Entity

Missing API key. The NOWNodes gateway returns plain text for this error.

500Internal Server Error

Internal Server Error. The gateway or backend failed while processing the request.

Generate address from xpub

curl -X GET 'https://ada-blockfrost.nownodes.io/utils/addresses/xpub/{address}/{role}/{index}'

const response = await fetch('https://ada-blockfrost.nownodes.io/utils/addresses/xpub/{address}/{role}/{index}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/utils/addresses/xpub/{address}/{role}/{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://ada-blockfrost.nownodes.io/utils/addresses/xpub/{address}/{role}/{index}')
data = response.json()

const response = await fetch('https://ada-blockfrost.nownodes.io/utils/addresses/xpub/{address}/{role}/{index}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ada-blockfrost.nownodes.io/utils/addresses/xpub/{address}/{role}/{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://ada-blockfrost.nownodes.io/utils/addresses/xpub/{address}/{role}/{index}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ada-blockfrost.nownodes.io/utils/addresses/xpub/{address}/{role}/{index}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ada-blockfrost.nownodes.io/utils/addresses/xpub/{address}/{role}/{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)

[]

{
  "code": 4000,
  "message": "Invalid request",
  "retriable": false
}

{
  "status_code": 400,
  "message": "Bad Request",
  "error": "bad_request"
}

Unknown API_key

Missing API_key

{
  "status_code": 500,
  "message": "Internal Server Error",
  "error": "internal_server_error"
}

Documentation

How to migrate to NOWNodes

Authentication

Blockfrost

Health

Authorizations

Response

Authorizations

Response

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

Addresses

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Assets

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Blocks

Authorizations