Polkadot REST API

v0.1.1

Base URL

https://ksm-playbook.nownodes.io

High-performance Rust REST API for Substrate/Polkadot blockchain data. Drop-in replacement for substrate-api-sidecar.

Authentication

api-keyAuthapiKey

API Key: api-key in header

NODE

health

Health check

GET

https://ksm-playbook.nownodes.io/v1/health

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the health status of the API server.

Response

202Accepted

API is healthy

Health check

curl -X GET 'https://ksm-playbook.nownodes.io/v1/health'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/health')
data = response.json()

require 'net/http'
require 'json'

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

202

{
  "connected_chains": 0,
  "status": "string",
  "uptime": 0
}

node

Connected node information

Node network info

GET

https://ksm-playbook.nownodes.io/v1/node/network

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the node's network information including peer count, syncing status, and local peer ID.

Response

200OK

Node network information

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Node network info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/node/network'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/node/network', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/node/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://ksm-playbook.nownodes.io/v1/node/network')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/node/network', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/node/network')
data = response.json()

require 'net/http'
require 'json'

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

200

{}

Transaction pool

GET

https://ksm-playbook.nownodes.io/v1/node/transaction-pool

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the node's transaction pool with optional fee information.

Parameters

includeFeebooleanquery

Include fee details for each transaction

Response

200OK

Transaction pool entries

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Transaction pool

curl -X GET 'https://ksm-playbook.nownodes.io/v1/node/transaction-pool'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/node/transaction-pool', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/node/transaction-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://ksm-playbook.nownodes.io/v1/node/transaction-pool')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/node/transaction-pool', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/node/transaction-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://ksm-playbook.nownodes.io/v1/node/transaction-pool', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/node/transaction-pool')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/node/transaction-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)

200

{
  "pool": [
    {
      "encodedExtrinsic": "string",
      "hash": "string",
      "partialFee": "string",
      "priority": "string",
      "tip": "string"
    }
  ]
}

Node version

GET

https://ksm-playbook.nownodes.io/v1/node/version

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the node's version information including client version, implementation name, and chain name.

Response

200OK

Node version information

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Node version

curl -X GET 'https://ksm-playbook.nownodes.io/v1/node/version'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/node/version', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/node/version')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/node/version')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/node/version', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/node/version";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/node/version', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/node/version')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/node/version')
request = Net::HTTP::Get.new(uri)

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

200

{
  "chain": "string",
  "clientImplName": "string",
  "clientVersion": "string"
}

version

API version

GET

https://ksm-playbook.nownodes.io/v1/version

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the current version of the Polkadot REST API.

Response

200OK

API version

curl -X GET 'https://ksm-playbook.nownodes.io/v1/version'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/version', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/version')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/version')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/version', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/version";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/version', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/version')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/version')
request = Net::HTTP::Get.new(uri)

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

200

{
  "version": "string"
}

blocks

Block queries and extrinsic data

Get blocks by range

GET

https://ksm-playbook.nownodes.io/v1/blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a collection of blocks given a numeric range. Range is inclusive and limited to 500 blocks.

Parameters

rangestringquery

Block range in format 'start-end' (e.g. '100-200')

eventDocsbooleanquery

Include documentation for events

extrinsicDocsbooleanquery

Include documentation for extrinsics

noFeesbooleanquery

Skip fee calculation for extrinsics

useRcBlockbooleanquery

Treat range as Relay Chain blocks

useEvmFormatbooleanquery

Convert AccountId32 addresses to EVM format for revive pallet events

Response

200OK

Array of block information

400Bad Request

Invalid range parameter

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get blocks by range

curl -X GET 'https://ksm-playbook.nownodes.io/v1/blocks'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

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

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

const data = await response.json();

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

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

  return response.json();
}

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

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

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

200

[
  {}
]

Get latest block

GET

https://ksm-playbook.nownodes.io/v1/blocks/head

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the latest finalized or canonical block with full extrinsic and event details.

Parameters

finalizedbooleanquery

When true (default), returns finalized head. When false, returns canonical head.

eventDocsbooleanquery

Include documentation for events

extrinsicDocsbooleanquery

Include documentation for extrinsics

noFeesbooleanquery

Skip fee calculation for extrinsics

decodedXcmMsgsbooleanquery

Decode and include XCM messages

paraIdinteger<int32>>= 0query

Filter XCM messages by parachain ID

useRcBlockbooleanquery

When true, use relay chain head to find corresponding Asset Hub blocks

useEvmFormatbooleanquery

Convert AccountId32 addresses to EVM format for revive pallet events

Response

200OK

Latest block information

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get latest block

curl -X GET 'https://ksm-playbook.nownodes.io/v1/blocks/head'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/head')
data = response.json()

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

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/blocks/head";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/head')
data = response.json()

require 'net/http'
require 'json'

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

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

200

{}

Get head block header

GET

https://ksm-playbook.nownodes.io/v1/blocks/head/header

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the header of the latest finalized or canonical block (lightweight, no extrinsics/events).

Parameters

finalizedbooleanquery

When true (default), returns finalized head header. When false, returns canonical head header.

useRcBlockbooleanquery

Treat as Relay Chain block and return Asset Hub blocks

Response

200OK

Block header information

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get head block header

curl -X GET 'https://ksm-playbook.nownodes.io/v1/blocks/head/header'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/head/header', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/head/header')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/head/header')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/head/header', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/blocks/head/header";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/head/header', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/head/header')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/head/header')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get block by ID

GET

https://ksm-playbook.nownodes.io/v1/blocks/{blockId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns block information for a given block identifier (hash or number), including extrinsics, events, and fees.

Parameters

blockIdstringrequiredpath

Block height number or block hash

eventDocsbooleanquery

Include documentation for events

extrinsicDocsbooleanquery

Include documentation for extrinsics

noFeesbooleanquery

Skip fee calculation for extrinsics

finalizedKeybooleanquery

When true (default), include finalized status in response

decodedXcmMsgsbooleanquery

Decode and include XCM messages

paraIdinteger<int32>>= 0query

Filter XCM messages by parachain ID

useRcBlockbooleanquery

Treat blockId as Relay Chain block and return Asset Hub blocks

useEvmFormatbooleanquery

Convert AccountId32 addresses to EVM format for revive pallet events

Response

200OK

Block information

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get block by ID

curl -X GET 'https://ksm-playbook.nownodes.io/v1/blocks/{blockId}'

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

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}')
data = response.json()

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

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/blocks/{blockId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get raw extrinsics

GET

https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics-raw

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns raw block data with hex-encoded extrinsics for a given block identifier. The extrinsics are returned as raw hex strings without decoding.

Parameters

blockIdstringrequiredpath

Block height number or block hash

useRcBlockbooleanquery

When true, treat blockId as Relay Chain block and return Asset Hub blocks

Response

200OK

Raw block data with hex-encoded extrinsics

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get raw extrinsics

curl -X GET 'https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics-raw'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics-raw', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics-raw')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics-raw')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics-raw', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics-raw";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics-raw', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics-raw')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics-raw')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get extrinsic by index

GET

https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics/{extrinsicIndex}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a specific extrinsic from a block by its index within the block.

Parameters

blockIdstringrequiredpath

Block height number or block hash

extrinsicIndexstringrequiredpath

Index of the extrinsic within the block

eventDocsbooleanquery

Include documentation for events

extrinsicDocsbooleanquery

Include documentation for extrinsics

noFeesbooleanquery

Skip fee calculation

useRcBlockbooleanquery

When true, treat blockId as Relay Chain block and return Asset Hub extrinsics

useEvmFormatbooleanquery

Convert AccountId32 addresses to EVM format for revive pallet events

Response

200OK

Extrinsic details

400Bad Request

Invalid block identifier or extrinsic index

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get extrinsic by index

curl -X GET 'https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics/{extrinsicIndex}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics/{extrinsicIndex}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics/{extrinsicIndex}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics/{extrinsicIndex}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics/{extrinsicIndex}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics/{extrinsicIndex}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics/{extrinsicIndex}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics/{extrinsicIndex}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/extrinsics/{extrinsicIndex}')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get block header by ID

GET

https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/header

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the header of the specified block (lightweight, no extrinsics/events).

Parameters

blockIdstringrequiredpath

Block height number or block hash

useRcBlockbooleanquery

Treat blockId as Relay Chain block and return Asset Hub blocks

Response

200OK

Block header information

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get block header by ID

curl -X GET 'https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/header'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/header', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/header')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/header')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/header', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/header";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/header', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/header')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/header')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get parachain inclusions

GET

https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/para-inclusions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns parachain inclusion information for a given relay chain block. Extracts CandidateIncluded events from the ParaInclusion pallet.

Parameters

blockIdstringrequiredpath

Block height number or block hash

paraIdinteger<int32>>= 0query

Filter results by a specific parachain ID

Response

200OK

Parachain inclusion information

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get parachain inclusions

curl -X GET 'https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/para-inclusions'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/para-inclusions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/para-inclusions')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/para-inclusions')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/para-inclusions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/para-inclusions";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/para-inclusions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/para-inclusions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/blocks/{blockId}/para-inclusions')
request = Net::HTTP::Get.new(uri)

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

200

{}

accounts

Account balance, staking, and proxy information

Compare account addresses

GET

https://ksm-playbook.nownodes.io/v1/accounts/compare

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Compares multiple SS58 addresses to determine if they have the same underlying public key.

Parameters

addressesstringrequiredquery

Comma-separated list of SS58 addresses to compare (max 30)

Response

200OK

Comparison result

400Bad Request

Invalid parameters

Compare account addresses

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/compare'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/compare')
data = response.json()

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

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/compare";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

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

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/compare')
data = response.json()

require 'net/http'
require 'json'

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

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

200

{
  "addresses": [
    {
      "network": "string",
      "publicKey": "string",
      "ss58Format": "string",
      "ss58Prefix": 0
    }
  ],
  "areEqual": true
}

Account asset approvals

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-approvals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns asset approval information for a given account, asset, and delegate.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

assetIdstringrequiredquery

The asset ID to query approval for

delegatestringrequiredquery

The delegate address with spending approval

Response

200OK

Asset approval information

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Account asset approvals

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-approvals'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-approvals', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-approvals')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-approvals')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-approvals', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-approvals";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-approvals', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-approvals')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-approvals')
request = Net::HTTP::Get.new(uri)

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

200

{
  "ahTimestamp": "string",
  "amount": "string",
  "at": {
    "hash": "string",
    "height": "string"
  },
  "deposit": "string",
  "rcBlockHash": "string",
  "rcBlockNumber": "string"
}

Account asset balances

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-balances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns asset balances for a given account on Asset Hub chains.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

assetsstringquery

Comma-separated list of asset IDs to query

showEmptybooleanquery

When true, include assets with zero balance (default: false)

Response

200OK

Account asset balances

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Account asset balances

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-balances'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-balances', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-balances')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-balances')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-balances', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-balances";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-balances', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-balances')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/asset-balances')
request = Net::HTTP::Get.new(uri)

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

200

{
  "ahTimestamp": "string",
  "assets": [
    {
      "assetId": "string",
      "balance": "string",
      "isFrozen": true,
      "isSufficient": true
    }
  ],
  "at": {
    "hash": "string",
    "height": "string"
  },
  "rcBlockHash": "string",
  "rcBlockNumber": "string"
}

Account balance info

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/balance-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns balance information for a given account including free, reserved, and locked balances.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

tokenstringquery

Token symbol for chains with multiple tokens

denominatedbooleanquery

When true, denominate balances using chain decimals

Response

200OK

Account balance information

400Bad Request

Invalid account or block parameter

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Account balance info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/balance-info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/balance-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/balance-info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/balance-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/balance-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/balance-info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/balance-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/balance-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/balance-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "ahTimestamp": "string",
  "at": {
    "hash": "string",
    "height": "string"
  },
  "feeFrozen": "string",
  "free": "string",
  "frozen": "string",
  "locks": [
    {
      "amount": "string",
      "id": "string",
      "reasons": "string"
    }
  ],
  "miscFrozen": "string",
  "nonce": "string",
  "rcBlockHash": "string",
  "rcBlockNumber": "string",
  "reserved": "string",
  "tokenSymbol": "string",
  "transferable": "string"
}

Convert account format

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/convert

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Converts an account address between different SS58 formats and key types.

Parameters

accountIdstringrequiredpath

SS58-encoded account address or hex public key

schemestringquery

Cryptographic scheme: ed25519, sr25519, or ecdsa (default: sr25519)

prefixinteger<int32>>= 0query

SS58 prefix number (default: 42)

publicKeybooleanquery

If true, treat input as a public key

Response

200OK

Converted account information

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Convert account format

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/convert'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/convert', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/convert')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/convert')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/convert', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/convert";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/convert', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/convert')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/convert')
request = Net::HTTP::Get.new(uri)

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

200

{
  "accountId": "string",
  "address": "string",
  "network": "string",
  "publicKey": true,
  "scheme": "string",
  "ss58Prefix": 0
}

Account foreign asset balances

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/foreign-asset-balances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns foreign asset balances for a given account on Asset Hub chains. Foreign assets use XCM MultiLocation as their identifier.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

foreignAssetsArray<string>query

List of multilocation JSON strings to filter by

showEmptybooleanquery

When true, include assets with zero balance (default: false)

Response

200OK

Foreign asset balances

400Bad Request

Invalid account or parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Account foreign asset balances

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/foreign-asset-balances'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/foreign-asset-balances', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/foreign-asset-balances')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/foreign-asset-balances')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/foreign-asset-balances', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/foreign-asset-balances";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/foreign-asset-balances', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/foreign-asset-balances')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/foreign-asset-balances')
request = Net::HTTP::Get.new(uri)

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

200

{}

Account pool asset approvals

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-approvals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns pool asset approval information for a given account, asset, and delegate.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

assetIdstringrequiredquery

The pool asset ID to query approval for

delegatestringrequiredquery

The delegate address with spending approval

Response

200OK

Pool asset approval information

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Account pool asset approvals

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-approvals'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-approvals', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-approvals')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-approvals')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-approvals', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-approvals";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-approvals', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-approvals')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-approvals')
request = Net::HTTP::Get.new(uri)

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

200

{
  "ahTimestamp": "string",
  "amount": "string",
  "at": {
    "hash": "string",
    "height": "string"
  },
  "deposit": "string",
  "rcBlockHash": "string",
  "rcBlockNumber": "string"
}

Account pool asset balances

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-balances

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns pool asset balances for a given account.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

assetsstringquery

Comma-separated list of pool asset IDs to query

showEmptybooleanquery

When true, include assets with zero balance (default: false)

Response

200OK

Pool asset balances

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Account pool asset balances

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-balances'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-balances', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-balances')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-balances')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-balances', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-balances";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-balances', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-balances')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/pool-asset-balances')
request = Net::HTTP::Get.new(uri)

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

200

{
  "ahTimestamp": "string",
  "at": {
    "hash": "string",
    "height": "string"
  },
  "poolAssets": [
    {
      "assetId": "string",
      "balance": "string",
      "isFrozen": true,
      "isSufficient": true
    }
  ],
  "rcBlockHash": "string",
  "rcBlockNumber": "string"
}

Account proxy info

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/proxy-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns proxy information for a given account including delegated proxies and their types.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Proxy information

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Account proxy info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/proxy-info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/proxy-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/proxy-info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/proxy-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/proxy-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/proxy-info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/proxy-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/proxy-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/proxy-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "ahTimestamp": "string",
  "at": {
    "hash": "string",
    "height": "string"
  },
  "delegatedAccounts": [
    {
      "delay": "string",
      "delegate": "string",
      "proxyType": "string"
    }
  ],
  "depositHeld": "string",
  "rcBlockHash": "string",
  "rcBlockNumber": "string"
}

Account staking info

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns staking information for a given stash account including bonded amount, controller, and nominations.

Parameters

accountIdstringrequiredpath

SS58-encoded stash account address

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

includeClaimedRewardsbooleanquery

When true, include claimed rewards in the response

Response

200OK

Staking information

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Account staking info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "ahTimestamp": "string",
  "at": {
    "hash": "string",
    "height": "string"
  },
  "controller": "string",
  "nominations": {
    "submittedIn": "string",
    "suppressed": true,
    "targets": [
      "string"
    ]
  },
  "numSlashingSpans": "string",
  "rcBlockHash": "string",
  "rcBlockNumber": "string",
  "rewardDestination": {
    "staked": null
  },
  "staking": {
    "active": "string",
    "claimedRewards": [
      {
        "era": "string",
        "status": "string"
      }
    ],
    "stash": "string",
    "total": "string",
    "unlocking": [
      {
        "era": "string",
        "value": "string"
      }
    ]
  }
}

Account staking payouts

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-payouts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns staking payout history for a given account including era rewards and claimed status.

Parameters

accountIdstringrequiredpath

SS58-encoded stash account address

atstringquery

Block hash or number to query at

depthstringquery

Number of eras to query (default: 1)

erastringquery

The era to query at (default: active_era - 1)

unclaimedOnlybooleanquery

Only show unclaimed rewards (default: true)

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Staking payout information

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Account staking payouts

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-payouts'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-payouts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-payouts')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-payouts')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-payouts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-payouts";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-payouts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-payouts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/staking-payouts')
request = Net::HTTP::Get.new(uri)

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

200

{
  "ahTimestamp": "string",
  "at": {
    "hash": "string",
    "height": "string"
  },
  "erasPayouts": [
    {
      "era": "string",
      "payouts": [
        {
          "claimed": true,
          "nominatorExposure": "string",
          "nominatorStakingPayout": "string",
          "totalValidatorExposure": "string",
          "totalValidatorRewardPoints": "string",
          "validatorCommission": "string",
          "validatorId": "string"
        }
      ],
      "totalEraPayout": "string",
      "totalEraRewardPoints": "string"
    }
  ],
  "rcBlockHash": "string",
  "rcBlockNumber": "string"
}

Validate account address

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/validate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Validates an SS58-encoded account address and returns details about its format.

Parameters

accountIdstringrequiredpath

SS58-encoded account address to validate

atstringquery

Block hash or number (accepted for API consistency)

Response

200OK

Validation result

Validate account address

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/validate'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/validate', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/validate')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/validate')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/validate', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/validate";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/validate', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/validate')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/validate')
request = Net::HTTP::Get.new(uri)

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

200

{
  "accountId": "string",
  "isValid": true,
  "network": "string",
  "ss58Prefix": "string"
}

Account vesting info

GET

https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/vesting-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns vesting information for a given account including vesting schedules and locked amounts.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

includeClaimablebooleanquery

When true, calculate vested amounts

Response

200OK

Vesting information

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Account vesting info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/vesting-info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/vesting-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/vesting-info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/vesting-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/vesting-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/vesting-info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/vesting-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/vesting-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/accounts/{accountId}/vesting-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "ahTimestamp": "string",
  "at": {
    "hash": "string",
    "height": "string"
  },
  "rcBlockHash": "string",
  "rcBlockNumber": "string",
  "vesting": [
    {
      "locked": "string",
      "perBlock": "string",
      "startingBlock": "string"
    }
  ]
}

pallets

Runtime pallet metadata, storage, constants, events, errors

Liquidity pools

GET

https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/liquidity-pools

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all liquidity pools from the AssetConversion pallet.

Parameters

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Liquidity pools

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Liquidity pools

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/liquidity-pools'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/liquidity-pools', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/liquidity-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://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/liquidity-pools')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/liquidity-pools', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/liquidity-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://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/liquidity-pools', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/liquidity-pools')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/liquidity-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)

200

{}

Next available pool ID

GET

https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/next-available-id

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the next available pool asset ID from the AssetConversion pallet.

Parameters

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Next available ID

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Next available pool ID

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/next-available-id'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/next-available-id', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/next-available-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://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/next-available-id')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/next-available-id', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/next-available-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://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/next-available-id', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/next-available-id')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/asset-conversion/next-available-id')
request = Net::HTTP::Get.new(uri)

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

200

{}

Asset info

GET

https://ksm-playbook.nownodes.io/v1/pallets/assets/{assetId}/asset-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns details for a specific asset including supply, admin, and metadata.

Parameters

assetIdstringrequiredpath

Asset ID

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Asset information

404Not Found

Asset not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Asset info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/assets/{assetId}/asset-info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/assets/{assetId}/asset-info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/assets/{assetId}/asset-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/assets/{assetId}/asset-info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/assets/{assetId}/asset-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/assets/{assetId}/asset-info')
request = Net::HTTP::Get.new(uri)

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

200

{}

Foreign assets

GET

https://ksm-playbook.nownodes.io/v1/pallets/foreign-assets

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all foreign assets with their details and metadata. Foreign assets use XCM MultiLocation as their identifier.

Parameters

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Foreign assets list

400Bad Request

Not supported on this chain

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Foreign assets

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/foreign-assets'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/foreign-assets', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/foreign-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://ksm-playbook.nownodes.io/v1/pallets/foreign-assets')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/foreign-assets', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/foreign-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://ksm-playbook.nownodes.io/v1/pallets/foreign-assets', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/foreign-assets')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/foreign-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)

200

{}

Nomination pools info

GET

https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns global nomination pools statistics and configuration.

Parameters

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Nomination pools information

400Bad Request

Not supported on this chain

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Nomination pools info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/info')
request = Net::HTTP::Get.new(uri)

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

200

{}

Nomination pool details

GET

https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/{poolId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns details for a specific nomination pool.

Parameters

poolIdstringrequiredpath

Pool ID

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Pool details

404Not Found

Pool not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Nomination pool details

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/{poolId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/{poolId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/{poolId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/{poolId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/{poolId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/{poolId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/{poolId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/{poolId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/nomination-pools/{poolId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

On-going referenda

GET

https://ksm-playbook.nownodes.io/v1/pallets/on-going-referenda

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all currently active referenda from the Referenda pallet.

Parameters

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Active referenda

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

On-going referenda

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/on-going-referenda'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/on-going-referenda', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/on-going-referenda')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/on-going-referenda')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/on-going-referenda', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/on-going-referenda";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/on-going-referenda', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/on-going-referenda')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/on-going-referenda')
request = Net::HTTP::Get.new(uri)

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

200

{}

Pool asset info

GET

https://ksm-playbook.nownodes.io/v1/pallets/pool-assets/{assetId}/asset-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns details for a specific pool asset including supply, admin, and metadata.

Parameters

assetIdstringrequiredpath

Pool asset ID

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Pool asset information

404Not Found

Pool asset not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Pool asset info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/pool-assets/{assetId}/asset-info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/pool-assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/pool-assets/{assetId}/asset-info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/pool-assets/{assetId}/asset-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/pool-assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/pool-assets/{assetId}/asset-info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/pool-assets/{assetId}/asset-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/pool-assets/{assetId}/asset-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/pool-assets/{assetId}/asset-info')
request = Net::HTTP::Get.new(uri)

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

200

{}

Staking progress

GET

https://ksm-playbook.nownodes.io/v1/pallets/staking/progress

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns staking progress including era, session info, and validator counts.

Parameters

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Staking progress information

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Staking progress

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/staking/progress'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/staking/progress')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/staking/progress')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/staking/progress";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/staking/progress')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/staking/progress')
request = Net::HTTP::Get.new(uri)

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

200

{}

Staking validators

GET

https://ksm-playbook.nownodes.io/v1/pallets/staking/validators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the list of active validators and their info.

Parameters

atstringquery

Block hash or number to query at

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Validator information

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Staking validators

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/staking/validators'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/staking/validators')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/staking/validators')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/staking/validators";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/staking/validators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/staking/validators')
request = Net::HTTP::Get.new(uri)

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

200

{}

Pallet constants

GET

https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all constants defined in a pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

atstringquery

Block hash or number to query at

onlyIdsbooleanquery

Only return constant names

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Pallet constants

400Bad Request

Invalid pallet

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Pallet constants

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts')
request = Net::HTTP::Get.new(uri)

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

200

{}

Pallet constant value

GET

https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts/{constantItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the value and metadata of a specific constant in a pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

constantItemIdstringrequiredpath

Name of the constant

atstringquery

Block hash or number to query at

metadatabooleanquery

Include metadata

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Constant value

400Bad Request

Invalid parameters

404Not Found

Constant not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Pallet constant value

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts/{constantItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts/{constantItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts/{constantItemId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts/{constantItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts/{constantItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts/{constantItemId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts/{constantItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts/{constantItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/consts/{constantItemId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

Pallet dispatchables

GET

https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the dispatchable calls defined in a pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

atstringquery

Block hash or number to query at

onlyIdsbooleanquery

Only return dispatchable names

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Pallet dispatchables

400Bad Request

Invalid pallet

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Pallet dispatchables

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables')
request = Net::HTTP::Get.new(uri)

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

200

{}

Pallet dispatchable details

GET

https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables/{dispatchableId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a single dispatchable call defined in a pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

dispatchableIdstringrequiredpath

Name of the dispatchable

atstringquery

Block hash or number to query at

metadatabooleanquery

Include metadata

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Dispatchable details

404Not Found

Dispatchable not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Pallet dispatchable details

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables/{dispatchableId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables/{dispatchableId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables/{dispatchableId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables/{dispatchableId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables/{dispatchableId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables/{dispatchableId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables/{dispatchableId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables/{dispatchableId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/dispatchables/{dispatchableId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

Pallet errors

GET

https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all errors defined in a pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

atstringquery

Block hash or number to query at

onlyIdsbooleanquery

Only return error names

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Pallet errors

400Bad Request

Invalid pallet

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Pallet errors

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors')
request = Net::HTTP::Get.new(uri)

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

200

{}

Pallet error details

GET

https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors/{errorItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns metadata for a specific error in a pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

errorItemIdstringrequiredpath

Name of the error

atstringquery

Block hash or number to query at

metadatabooleanquery

Include metadata

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Error details

404Not Found

Error not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Pallet error details

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors/{errorItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors/{errorItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors/{errorItemId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors/{errorItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors/{errorItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors/{errorItemId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors/{errorItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors/{errorItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/errors/{errorItemId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get pallet events

GET

https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all events defined in a pallet.

Parameters

palletIdstringrequiredpath

Pallet name or index

atstringquery

Block identifier (number or hash)

onlyIdsbooleanquery

Only return event names

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Pallet events

400Bad Request

Invalid request

404Not Found

Pallet not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get pallet events

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get pallet event item

GET

https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events/{eventItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns metadata for a specific event in a pallet.

Parameters

palletIdstringrequiredpath

Pallet name or index

eventItemIdstringrequiredpath

Event name

atstringquery

Block identifier (number or hash)

metadatabooleanquery

Include full event metadata

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Event item details

400Bad Request

Invalid request

404Not Found

Pallet or event not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get pallet event item

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events/{eventItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events/{eventItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events/{eventItemId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events/{eventItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events/{eventItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events/{eventItemId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events/{eventItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events/{eventItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/events/{eventItemId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

Pallet storage items

GET

https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the list of storage items for a given pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

atstringquery

Block hash or number to query at

onlyIdsbooleanquery

Only return storage item names

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Pallet storage items

400Bad Request

Invalid pallet or parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Pallet storage items

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage')
request = Net::HTTP::Get.new(uri)

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

200

{}

Pallet storage item value

GET

https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage/{storageItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the value of a specific storage item in a pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

storageItemIdstringrequiredpath

Name of the storage item

atstringquery

Block hash or number to query at

keys[]Array<string>query

Storage key arguments

metadatabooleanquery

Include metadata for the storage item

useRcBlockbooleanquery

Treat 'at' as relay chain block identifier

Response

200OK

Storage item value

400Bad Request

Invalid parameters

404Not Found

Storage item not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Pallet storage item value

curl -X GET 'https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage/{storageItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage/{storageItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage/{storageItemId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage/{storageItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage/{storageItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage/{storageItemId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage/{storageItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage/{storageItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/pallets/{palletId}/storage/{storageItemId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

runtime

Runtime specification, metadata, and code

Runtime Wasm code

GET

https://ksm-playbook.nownodes.io/v1/runtime/code

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the Wasm code blob of the Substrate runtime at a given block.

Parameters

atstringquery

Block hash or number to query at

Response

200OK

Runtime code

400Bad Request

Invalid block parameter

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Runtime Wasm code

curl -X GET 'https://ksm-playbook.nownodes.io/v1/runtime/code'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/code', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/runtime/code')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/runtime/code')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/code', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/runtime/code";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/code', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/runtime/code')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/runtime/code')
request = Net::HTTP::Get.new(uri)

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

200

{}

Runtime metadata

GET

https://ksm-playbook.nownodes.io/v1/runtime/metadata

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the decoded runtime metadata in JSON format.

Parameters

atstringquery

Block hash or number to query at

Response

200OK

Runtime metadata

400Bad Request

Invalid block parameter

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Runtime metadata

curl -X GET 'https://ksm-playbook.nownodes.io/v1/runtime/metadata'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/metadata', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/runtime/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://ksm-playbook.nownodes.io/v1/runtime/metadata')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/metadata', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/runtime/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://ksm-playbook.nownodes.io/v1/runtime/metadata', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/runtime/metadata')
data = response.json()

require 'net/http'
require 'json'

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

200

{}

Available metadata versions

GET

https://ksm-playbook.nownodes.io/v1/runtime/metadata/versions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the available metadata versions at a given block.

Parameters

atstringquery

Block hash or number to query at

Response

200OK

List of available metadata versions

400Bad Request

Invalid block parameter

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Available metadata versions

curl -X GET 'https://ksm-playbook.nownodes.io/v1/runtime/metadata/versions'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/metadata/versions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/runtime/metadata/versions')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/runtime/metadata/versions')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/metadata/versions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/runtime/metadata/versions";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/metadata/versions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/runtime/metadata/versions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/runtime/metadata/versions')
request = Net::HTTP::Get.new(uri)

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

200

[
  "string"
]

Runtime metadata by version

GET

https://ksm-playbook.nownodes.io/v1/runtime/metadata/{version}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the metadata at a specific version. The version parameter should be in 'vX' format (e.g., 'v14', 'v15').

Parameters

versionstringrequiredpath

Metadata version (e.g., 'v14', 'v15')

atstringquery

Block hash or number to query at

Response

200OK

Runtime metadata at specified version

400Bad Request

Invalid version format or block parameter

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Runtime metadata by version

curl -X GET 'https://ksm-playbook.nownodes.io/v1/runtime/metadata/{version}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/metadata/{version}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/runtime/metadata/{version}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/runtime/metadata/{version}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/metadata/{version}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/runtime/metadata/{version}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/metadata/{version}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/runtime/metadata/{version}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/runtime/metadata/{version}')
request = Net::HTTP::Get.new(uri)

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

200

{}

Runtime specification

GET

https://ksm-playbook.nownodes.io/v1/runtime/spec

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the runtime specification including version, APIs, and chain properties.

Parameters

atstringquery

Block hash or number to query at

Response

200OK

Runtime specification

400Bad Request

Invalid block parameter

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Runtime specification

curl -X GET 'https://ksm-playbook.nownodes.io/v1/runtime/spec'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/spec', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/runtime/spec')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/runtime/spec')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/spec', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/runtime/spec";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/runtime/spec', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/runtime/spec')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/runtime/spec')
request = Net::HTTP::Get.new(uri)

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

200

{}

transaction

Transaction submission, fee estimation, and construction material

Submit transaction

POST

https://ksm-playbook.nownodes.io/v1/transaction

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Submit a signed extrinsic to the transaction pool.

Body

application/json

Signed extrinsic with 'tx' field containing hex-encoded transaction

object

Response

200OK

Transaction hash

400Bad Request

Invalid transaction

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Submit transaction

curl -X POST 'https://ksm-playbook.nownodes.io/v1/transaction' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/transaction', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/transaction";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/transaction', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

Request Body

{}

200

{}

Dry run transaction

POST

https://ksm-playbook.nownodes.io/v1/transaction/dry-run

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Dry run a transaction to check validity without submitting.

Body

application/json

Transaction with 'tx', 'senderAddress', and optional 'at' fields

object

Response

200OK

Dry run result

400Bad Request

Invalid transaction

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Dry run transaction

curl -X POST 'https://ksm-playbook.nownodes.io/v1/transaction/dry-run' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/dry-run', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/dry-run')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/transaction/dry-run', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/dry-run', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/transaction/dry-run";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/dry-run', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/transaction/dry-run', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/dry-run')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

Request Body

{}

200

{}

Estimate transaction fee

POST

https://ksm-playbook.nownodes.io/v1/transaction/fee-estimate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Estimate the fee for a transaction.

Body

application/json

Transaction with 'tx' field containing hex-encoded transaction

object

Response

200OK

Fee estimate

400Bad Request

Invalid transaction

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Estimate transaction fee

curl -X POST 'https://ksm-playbook.nownodes.io/v1/transaction/fee-estimate' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/fee-estimate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/fee-estimate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/transaction/fee-estimate', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/fee-estimate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/transaction/fee-estimate";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/fee-estimate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/transaction/fee-estimate', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/fee-estimate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

Request Body

{}

200

{
  "class": "string",
  "partialFee": "string",
  "weight": {
    "proofSize": "string",
    "refTime": "string"
  }
}

Transaction construction material

GET

https://ksm-playbook.nownodes.io/v1/transaction/material

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns network information needed for transaction construction including genesis hash, spec version, and optionally metadata.

Parameters

atstringquery

Block hash or number to query at

noMetabooleanquery

DEPRECATED: If true, metadata is not included

metadatastringquery

Metadata format: 'json' or 'scale'

Response

200OK

Transaction material

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Transaction construction material

curl -X GET 'https://ksm-playbook.nownodes.io/v1/transaction/material'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/material', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/material')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/transaction/material')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/material', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/transaction/material";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/material', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/transaction/material')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/material')
request = Net::HTTP::Get.new(uri)

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

200

{}

Transaction material with versioned metadata

GET

https://ksm-playbook.nownodes.io/v1/transaction/material/{metadataVersion}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns transaction construction material with metadata at a specific version.

Parameters

metadataVersionstringrequiredpath

Metadata version (e.g., 'v14', 'v15')

atstringquery

Block hash or number to query at

noMetabooleanquery

DEPRECATED: If true, metadata is not included

metadatastringquery

Metadata format: 'json' or 'scale'

Response

200OK

Transaction material with versioned metadata

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Transaction material with versioned metadata

curl -X GET 'https://ksm-playbook.nownodes.io/v1/transaction/material/{metadataVersion}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/material/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/material/{metadataVersion}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/transaction/material/{metadataVersion}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/material/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/transaction/material/{metadataVersion}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/material/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/transaction/material/{metadataVersion}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/material/{metadataVersion}')
request = Net::HTTP::Get.new(uri)

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

200

{}

Generate metadata blob

POST

https://ksm-playbook.nownodes.io/v1/transaction/metadata-blob

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Generates a metadata blob for transaction signing with the CheckMetadataHash extension.

Body

application/json

Request with 'tx' field and optional 'at' block

object

Response

200OK

Metadata blob

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Generate metadata blob

curl -X POST 'https://ksm-playbook.nownodes.io/v1/transaction/metadata-blob' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/metadata-blob', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/metadata-blob')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/transaction/metadata-blob', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/metadata-blob', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/transaction/metadata-blob";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/metadata-blob', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/transaction/metadata-blob', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/metadata-blob')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

Request Body

{}

200

{}

Parse transaction

POST

https://ksm-playbook.nownodes.io/v1/transaction/parse

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Decode a raw transaction and return its components without executing or submitting it. Returns the decoded pallet/method, call arguments, signature info, nonce, tip, era, and hash. Note: This endpoint uses the chain's current (latest) metadata for decoding. Transactions created for older runtime versions may fail to decode if the extrinsic format has changed.

Body

application/json

Transaction with 'tx' field containing hex-encoded extrinsic

Request body for transaction parsing.

txstring

Hex-encoded extrinsic with optional 0x prefix.

Response

200OK

Parsed transaction

400Bad Request

Invalid transaction

500Internal Server Error

Internal server error

Parse transaction

curl -X POST 'https://ksm-playbook.nownodes.io/v1/transaction/parse' \
  -H 'Content-Type: application/json' \
  -d '{
    "tx": "0x4902840004316d995f..."
  }'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/parse', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "tx": "0x4902840004316d995f..."
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/parse')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "tx": "0x4902840004316d995f..."
  }'

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

import requests

payload = {
  "tx": "0x4902840004316d995f..."
}

response = requests.post('https://ksm-playbook.nownodes.io/v1/transaction/parse', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/parse', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "tx": "0x4902840004316d995f..."
    }),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/transaction/parse";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/transaction/parse', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "tx": "0x4902840004316d995f..."
    }),
});

const data = await response.json();

import requests

payload = {
  "tx": "0x4902840004316d995f..."
}

response = requests.post('https://ksm-playbook.nownodes.io/v1/transaction/parse', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/transaction/parse')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "tx": "0x4902840004316d995f..."
  }'

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

Request Body

{
  "tx": "0x4902840004316d995f..."
}

{
  "args": {},
  "era": {},
  "hash": "0x1234567890abcdef...",
  "isSigned": true,
  "method": {
    "method": "transferAllowDeath",
    "pallet": "balances"
  },
  "nonce": "42",
  "signature": {
    "signature": "0xa24152685f52e4726466e80247d965bb3d349637fc8a1ea6f7cc1451ddec98b5...",
    "signer": {
      "id": "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY"
    }
  },
  "tip": "0"
}

{
  "cause": "string",
  "code": 400,
  "error": "Failed to parse transaction.",
  "stack": "string",
  "transaction": "string"
}

coretime

Coretime system information

Get coretime info

GET

https://ksm-playbook.nownodes.io/v1/coretime/info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns coretime chain status information including the last committed timeslice.

Parameters

atstringquery

Block identifier (number or hash)

Response

200OK

Coretime info

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get coretime info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/coretime/info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/coretime/info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/info')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get coretime leases

GET

https://ksm-playbook.nownodes.io/v1/coretime/leases

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all leases registered on a coretime chain with task IDs and validity timeslices.

Parameters

atstringquery

Block identifier (number or hash)

Response

200OK

Coretime leases

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get coretime leases

curl -X GET 'https://ksm-playbook.nownodes.io/v1/coretime/leases'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/leases', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/leases')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/leases')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/leases', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/coretime/leases";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/leases', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/leases')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/leases')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get coretime overview

GET

https://ksm-playbook.nownodes.io/v1/coretime/overview

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns an overview of all cores with assignments, queue state, workload, workplan, and regions.

Parameters

atstringquery

Block identifier (number or hash)

Response

200OK

Coretime overview

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get coretime overview

curl -X GET 'https://ksm-playbook.nownodes.io/v1/coretime/overview'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/overview', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/overview')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/overview')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/overview', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/coretime/overview";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/overview', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/overview')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/overview')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get coretime regions

GET

https://ksm-playbook.nownodes.io/v1/coretime/regions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all regions on a coretime chain including begin/end timeslices, core, owner, and mask.

Parameters

atstringquery

Block identifier (number or hash)

Response

200OK

Coretime regions

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get coretime regions

curl -X GET 'https://ksm-playbook.nownodes.io/v1/coretime/regions'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/regions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/regions')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/regions')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/regions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/coretime/regions";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/regions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/regions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/regions')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get coretime potential renewals

GET

https://ksm-playbook.nownodes.io/v1/coretime/renewals

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns potential renewals on a coretime chain sorted by core index, including price, completion status, and task assignment.

Parameters

atstringquery

Block identifier (number or hash)

Response

200OK

Coretime renewals

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get coretime potential renewals

curl -X GET 'https://ksm-playbook.nownodes.io/v1/coretime/renewals'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/renewals', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/renewals')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/renewals')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/renewals', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/coretime/renewals";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/renewals', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/renewals')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/renewals')
request = Net::HTTP::Get.new(uri)

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

200

{}

Get coretime reservations

GET

https://ksm-playbook.nownodes.io/v1/coretime/reservations

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all reservations on a coretime chain. Reserved cores are permanently allocated and not available for sale.

Parameters

atstringquery

Block identifier (number or hash)

Response

200OK

Coretime reservations

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Get coretime reservations

curl -X GET 'https://ksm-playbook.nownodes.io/v1/coretime/reservations'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/reservations', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/reservations')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/reservations')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/reservations', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/coretime/reservations";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/coretime/reservations', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/coretime/reservations')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/coretime/reservations')
request = Net::HTTP::Get.new(uri)

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

200

{}

paras

Parachain inclusion data

GET

https://ksm-playbook.nownodes.io/v1/paras/{number}/inclusion

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns inclusion information for a given parachain block, searching relay chain blocks for when the parachain block was included.

Parameters

numberstringrequiredpath

Parachain block number

depthstringquery

Search depth for relay chain blocks (max 100, default 10, must be divisible by 5)

Response

200OK

Parachain inclusion information

400Bad Request

Invalid parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

Parachain inclusion data

curl -X GET 'https://ksm-playbook.nownodes.io/v1/paras/{number}/inclusion'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/paras/{number}/inclusion', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/paras/{number}/inclusion')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/paras/{number}/inclusion')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/paras/{number}/inclusion', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/paras/{number}/inclusion";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/paras/{number}/inclusion', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/paras/{number}/inclusion')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/paras/{number}/inclusion')
request = Net::HTTP::Get.new(uri)

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

200

{}

ahm

Asset Hub Migration information

Asset Hub Migration info

GET

https://ksm-playbook.nownodes.io/v1/ahm-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns information about the Asset Hub migration, including start and end blocks for both relay chain and Asset Hub.

Response

200OK

AHM migration boundaries

404Not Found

No migration data available

Asset Hub Migration info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/ahm-info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/ahm-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/ahm-info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/ahm-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/ahm-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/ahm-info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/ahm-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/ahm-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/ahm-info')
request = Net::HTTP::Get.new(uri)

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

200

{}

capabilities

API capabilities and chain pallets

API capabilities

GET

https://ksm-playbook.nownodes.io/v1/capabilities

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the chain name and list of available pallets in the runtime metadata.

Parameters

atstringquery

Block hash or number to query at

Response

200OK

Chain capabilities

400Bad Request

Invalid block parameter

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

API capabilities

curl -X GET 'https://ksm-playbook.nownodes.io/v1/capabilities'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/capabilities', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/capabilities')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/capabilities')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/capabilities', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/capabilities";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/capabilities', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/capabilities')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/capabilities')
request = Net::HTTP::Get.new(uri)

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

200

{
  "chain": "string",
  "pallets": [
    "string"
  ]
}

rc

Relay chain endpoints (available on parachains only)

RC get balance info

GET

https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/balance-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns balance information for a given account on the relay chain.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block identifier (number or hash)

tokenstringquery

Token symbol (defaults to native token)

denominatedbooleanquery

Denominate balances using chain decimals

Response

200OK

Balance information

400Bad Request

Invalid account address

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get balance info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/balance-info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/balance-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/balance-info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/balance-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/balance-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/balance-info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/balance-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/balance-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/balance-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "feeFrozen": "string",
  "free": "string",
  "frozen": "string",
  "locks": [
    {
      "amount": "string",
      "id": "string",
      "reasons": "string"
    }
  ],
  "miscFrozen": "string",
  "nonce": "string",
  "reserved": "string",
  "tokenSymbol": "string",
  "transferable": "string"
}

RC get proxy info

GET

https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/proxy-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns proxy information for a given account on the relay chain.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block identifier (number or hash)

Response

200OK

Proxy information

400Bad Request

Invalid account address

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get proxy info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/proxy-info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/proxy-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/proxy-info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/proxy-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/proxy-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/proxy-info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/proxy-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/proxy-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/proxy-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "delegatedAccounts": [
    {
      "delay": "string",
      "delegate": "string",
      "proxyType": "string"
    }
  ],
  "depositHeld": "string"
}

RC get staking info

GET

https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns staking information for a given stash account on the relay chain.

Parameters

accountIdstringrequiredpath

SS58-encoded stash account address

atstringquery

Block identifier (number or hash)

includeClaimedRewardsbooleanquery

When true, include claimed rewards in the response

Response

200OK

Staking information

400Bad Request

Invalid account address

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get staking info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "controller": "string",
  "nominations": {
    "submittedIn": "string",
    "suppressed": true,
    "targets": [
      "string"
    ]
  },
  "numSlashingSpans": "string",
  "rewardDestination": {
    "staked": null
  },
  "staking": {
    "active": "string",
    "claimedRewards": [
      {
        "era": "string",
        "status": "string"
      }
    ],
    "stash": "string",
    "total": "string",
    "unlocking": [
      {
        "era": "string",
        "value": "string"
      }
    ]
  }
}

RC get staking payouts

GET

https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-payouts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns staking payout information for a given account on the relay chain.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block identifier (number or hash)

depthinteger<int32>>= 0query

Number of eras to query (default: 1)

erainteger<int32>>= 0query

The era to query at (default: active_era - 1)

unclaimedOnlybooleanquery

Only show unclaimed rewards (default: true)

Response

200OK

Staking payouts

400Bad Request

Invalid account address

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get staking payouts

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-payouts'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-payouts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-payouts')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-payouts')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-payouts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-payouts";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-payouts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-payouts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/staking-payouts')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "erasPayouts": [
    {
      "era": "string",
      "payouts": [
        {
          "claimed": true,
          "nominatorExposure": "string",
          "nominatorStakingPayout": "string",
          "totalValidatorExposure": "string",
          "totalValidatorRewardPoints": "string",
          "validatorCommission": "string",
          "validatorId": "string"
        }
      ],
      "totalEraPayout": "string",
      "totalEraRewardPoints": "string"
    }
  ]
}

RC get vesting info

GET

https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/vesting-info

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns vesting information for a given account on the relay chain.

Parameters

accountIdstringrequiredpath

SS58-encoded account address

atstringquery

Block identifier (number or hash)

Response

200OK

Vesting information

400Bad Request

Invalid account address

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get vesting info

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/vesting-info'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/vesting-info', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/vesting-info')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/vesting-info')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/vesting-info', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/vesting-info";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/vesting-info', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/vesting-info')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/accounts/{accountId}/vesting-info')
request = Net::HTTP::Get.new(uri)

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

200

{
  "at": {
    "hash": "string",
    "height": "string"
  },
  "vesting": [
    {
      "locked": "string",
      "perBlock": "string",
      "startingBlock": "string"
    }
  ]
}

RC get blocks by range

GET

https://ksm-playbook.nownodes.io/v1/rc/blocks

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns relay chain blocks within a specified range (max 500 blocks).

Parameters

rangestringquery

Block range (e.g., '100-200')

eventDocsbooleanquery

Include event documentation

extrinsicDocsbooleanquery

Include extrinsic documentation

noFeesbooleanquery

Skip fee calculation

decodedXcmMsgsbooleanquery

Decode and include XCM messages

paraIdinteger<int32>>= 0query

Filter XCM messages by parachain ID

Response

200OK

Relay chain blocks

400Bad Request

Invalid range or missing parameter

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get blocks by range

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/blocks'

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

const data = await response.json();

require 'net/http'
require 'json'

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

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

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks')
data = response.json()

require 'net/http'
require 'json'

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

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

200

{}

RC get head block

GET

https://ksm-playbook.nownodes.io/v1/rc/blocks/head

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the latest block on the relay chain.

Parameters

finalizedbooleanquery

When true returns finalized head (default: true)

eventDocsbooleanquery

Include event documentation

extrinsicDocsbooleanquery

Include extrinsic documentation

noFeesbooleanquery

Skip fee calculation

decodedXcmMsgsbooleanquery

Decode and include XCM messages

paraIdinteger<int32>>= 0query

Filter XCM messages by parachain ID

Response

200OK

Relay chain head block

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get head block

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/blocks/head'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/head', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/head')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/head')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/head', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/blocks/head";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/head', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/head')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/head')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC get head block header

GET

https://ksm-playbook.nownodes.io/v1/rc/blocks/head/header

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the header of the latest relay chain block.

Parameters

finalizedbooleanquery

When true returns finalized head (default: true)

Response

200OK

Relay chain head block header

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get head block header

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/blocks/head/header'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/head/header', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/head/header')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/head/header')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/head/header', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/blocks/head/header";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/head/header', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/head/header')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/head/header')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC get block by ID

GET

https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns relay chain block information for a given block identifier.

Parameters

blockIdstringrequiredpath

Block height number or block hash

eventDocsbooleanquery

Include event documentation

extrinsicDocsbooleanquery

Include extrinsic documentation

noFeesbooleanquery

Skip fee calculation

decodedXcmMsgsbooleanquery

Include decoded XCM messages

paraIdinteger<int32>>= 0query

Filter XCM messages by parachain ID

Response

200OK

Relay chain block information

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get block by ID

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC get raw extrinsics

GET

https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics-raw

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns raw hex-encoded extrinsics for a relay chain block without decoding.

Parameters

blockIdstringrequiredpath

Block height number or block hash

Response

200OK

Raw extrinsics

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get raw extrinsics

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics-raw'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics-raw', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics-raw')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics-raw')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics-raw', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics-raw";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics-raw', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics-raw')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics-raw')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC get extrinsic by index

GET

https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics/{extrinsicIndex}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a specific extrinsic from a relay chain block by its index.

Parameters

blockIdstringrequiredpath

Block height number or block hash

extrinsicIndexstringrequiredpath

Index of the extrinsic in the block

eventDocsbooleanquery

Include event documentation

extrinsicDocsbooleanquery

Include extrinsic documentation

noFeesbooleanquery

Skip fee calculation

Response

200OK

Extrinsic details

400Bad Request

Invalid block ID or extrinsic index

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get extrinsic by index

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics/{extrinsicIndex}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics/{extrinsicIndex}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics/{extrinsicIndex}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics/{extrinsicIndex}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics/{extrinsicIndex}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics/{extrinsicIndex}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics/{extrinsicIndex}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics/{extrinsicIndex}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/extrinsics/{extrinsicIndex}')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC get block header

GET

https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/header

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the header of a relay chain block by block hash or block number.

Parameters

blockIdstringrequiredpath

Block height number or block hash

Response

200OK

Relay chain block header

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get block header

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/header'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/header', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/header')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/header')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/header', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/header";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/header', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/header')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/header')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC get parachain inclusions

GET

https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/para-inclusions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns parachain inclusion information for a given relay chain block.

Parameters

blockIdstringrequiredpath

Block height number or block hash

paraIdinteger<int32>>= 0query

Filter by parachain ID

Response

200OK

Parachain inclusions

400Bad Request

Invalid block identifier

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get parachain inclusions

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/para-inclusions'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/para-inclusions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/para-inclusions')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/para-inclusions')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/para-inclusions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/para-inclusions";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/para-inclusions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/para-inclusions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/blocks/{blockId}/para-inclusions')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC get node network

GET

https://ksm-playbook.nownodes.io/v1/rc/node/network

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the relay chain node's network information.

Response

200OK

Relay chain node network info

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get node network

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/node/network'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/node/network', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/node/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://ksm-playbook.nownodes.io/v1/rc/node/network')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/node/network', {
  method: 'GET',
});

const data = await response.json();

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

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/node/network')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/node/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)

200

{}

RC get transaction pool

GET

https://ksm-playbook.nownodes.io/v1/rc/node/transaction-pool

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the relay chain's transaction pool with optional fee information.

Parameters

includeFeebooleanquery

Include fee information for each transaction (default: false)

Response

200OK

Relay chain transaction pool

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get transaction pool

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/node/transaction-pool'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/node/transaction-pool', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/node/transaction-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://ksm-playbook.nownodes.io/v1/rc/node/transaction-pool')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/node/transaction-pool', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/node/transaction-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://ksm-playbook.nownodes.io/v1/rc/node/transaction-pool', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/node/transaction-pool')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/node/transaction-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)

200

{
  "pool": [
    {
      "encodedExtrinsic": "string",
      "hash": "string",
      "partialFee": "string",
      "priority": "string",
      "tip": "string"
    }
  ]
}

RC get node version

GET

https://ksm-playbook.nownodes.io/v1/rc/node/version

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the relay chain node's version information.

Response

200OK

Relay chain node version

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get node version

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/node/version'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/node/version', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/node/version')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/node/version')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/node/version', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/node/version";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/node/version', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/node/version')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/node/version')
request = Net::HTTP::Get.new(uri)

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

200

{
  "chain": "string",
  "clientImplName": "string",
  "clientVersion": "string"
}

RC on-going referenda

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/on-going-referenda

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all currently active referenda from the relay chain's Referenda pallet.

Parameters

atstringquery

Block hash or number to query at

Response

200OK

Active referenda from relay chain

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC on-going referenda

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/on-going-referenda'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/on-going-referenda', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/on-going-referenda')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/on-going-referenda')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/on-going-referenda', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/on-going-referenda";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/on-going-referenda', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/on-going-referenda')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/on-going-referenda')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC staking progress

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/progress

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns staking progress from the relay chain.

Parameters

atstringquery

Block hash or number to query at

Response

200OK

Relay chain staking progress

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC staking progress

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/progress'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/progress')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/progress')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/progress";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/progress', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/progress')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/progress')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC staking validators

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/validators

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the list of active validators from the relay chain.

Parameters

atstringquery

Block hash or number to query at

Response

200OK

Relay chain validator information

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC staking validators

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/validators'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/validators')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/validators')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/validators";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/validators', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/validators')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/staking/validators')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC pallet constants

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all constants defined in a relay chain pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

atstringquery

Block hash or number to query at

onlyIdsbooleanquery

Only return constant names

Response

200OK

Relay chain pallet constants

400Bad Request

Invalid pallet

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC pallet constants

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC pallet constant value

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts/{constantItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the value and metadata of a specific constant from a relay chain pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

constantItemIdstringrequiredpath

Name of the constant

atstringquery

Block hash or number to query at

metadatabooleanquery

Include metadata

Response

200OK

Relay chain constant value

404Not Found

Constant not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC pallet constant value

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts/{constantItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts/{constantItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts/{constantItemId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts/{constantItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts/{constantItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts/{constantItemId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts/{constantItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts/{constantItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/consts/{constantItemId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC pallet dispatchables

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the dispatchable calls defined in a relay chain pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

atstringquery

Block hash or number to query at

onlyIdsbooleanquery

Only return dispatchable names

Response

200OK

Relay chain pallet dispatchables

400Bad Request

Invalid pallet

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC pallet dispatchables

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC pallet dispatchable details

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables/{dispatchableId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns a single dispatchable call from a relay chain pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

dispatchableIdstringrequiredpath

Name of the dispatchable

atstringquery

Block hash or number to query at

metadatabooleanquery

Include metadata

Response

200OK

Relay chain dispatchable details

404Not Found

Dispatchable not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC pallet dispatchable details

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables/{dispatchableId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables/{dispatchableId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables/{dispatchableId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables/{dispatchableId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables/{dispatchableId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables/{dispatchableId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables/{dispatchableId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables/{dispatchableId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/dispatchables/{dispatchableId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC pallet errors

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all errors defined in a relay chain pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

atstringquery

Block hash or number to query at

onlyIdsbooleanquery

Only return error names

Response

200OK

Relay chain pallet errors

400Bad Request

Invalid pallet

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC pallet errors

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC pallet error details

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors/{errorItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns metadata for a specific error in a relay chain pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

errorItemIdstringrequiredpath

Name of the error

atstringquery

Block hash or number to query at

metadatabooleanquery

Include metadata

Response

200OK

Relay chain error details

404Not Found

Error not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC pallet error details

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors/{errorItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors/{errorItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors/{errorItemId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors/{errorItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors/{errorItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors/{errorItemId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors/{errorItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors/{errorItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/errors/{errorItemId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC pallet events

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns all events defined in a relay chain pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

atstringquery

Block hash or number to query at

onlyIdsbooleanquery

Only return event names

Response

200OK

Relay chain pallet events

400Bad Request

Invalid pallet

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC pallet events

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC pallet event details

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events/{eventItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns metadata for a specific event in a relay chain pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

eventItemIdstringrequiredpath

Event name

atstringquery

Block hash or number to query at

metadatabooleanquery

Include full event metadata

Response

200OK

Relay chain event details

404Not Found

Pallet or event not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC pallet event details

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events/{eventItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events/{eventItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events/{eventItemId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events/{eventItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events/{eventItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events/{eventItemId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events/{eventItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events/{eventItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/events/{eventItemId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC pallet storage items

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the list of storage items for a relay chain pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

atstringquery

Block hash or number to query at

onlyIdsbooleanquery

Only return storage item names

Response

200OK

Relay chain pallet storage items

400Bad Request

Invalid pallet or parameters

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC pallet storage items

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC pallet storage item value

GET

https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage/{storageItemId}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the value of a specific storage item from a relay chain pallet.

Parameters

palletIdstringrequiredpath

Name or index of the pallet

storageItemIdstringrequiredpath

Name of the storage item

atstringquery

Block hash or number to query at

keys[]Array<string>query

Storage key arguments

metadatabooleanquery

Include metadata for the storage item

Response

200OK

Relay chain storage item value

400Bad Request

Invalid parameters

404Not Found

Storage item not found

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC pallet storage item value

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage/{storageItemId}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage/{storageItemId}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage/{storageItemId}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage/{storageItemId}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage/{storageItemId}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage/{storageItemId}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage/{storageItemId}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage/{storageItemId}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/pallets/{palletId}/storage/{storageItemId}')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC get runtime code

GET

https://ksm-playbook.nownodes.io/v1/rc/runtime/code

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the Wasm code blob of the relay chain runtime at a given block.

Parameters

atstringquery

Block identifier (number or hash)

Response

200OK

Relay chain runtime code

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get runtime code

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/runtime/code'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/code', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/runtime/code')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/runtime/code')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/code', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/runtime/code";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/code', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/runtime/code')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/runtime/code')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC get runtime metadata

GET

https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the decoded runtime metadata of the relay chain in JSON format.

Parameters

atstringquery

Block identifier (number or hash)

Response

200OK

Relay chain runtime metadata

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get runtime metadata

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/runtime/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://ksm-playbook.nownodes.io/v1/rc/runtime/metadata')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/runtime/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://ksm-playbook.nownodes.io/v1/rc/runtime/metadata', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/runtime/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)

200

{}

RC get metadata versions

GET

https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/versions

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the available metadata versions on the relay chain at a given block.

Parameters

atstringquery

Block identifier (number or hash)

Response

200OK

Available metadata versions

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get metadata versions

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/versions'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/versions', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/versions')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/versions')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/versions', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/versions";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/versions', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/versions')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/versions')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC get metadata by version

GET

https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/{version}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the relay chain metadata at a specific version (e.g., v14, v15).

Parameters

versionstringrequiredpath

Metadata version in 'vX' format (e.g., v14, v15)

atstringquery

Block identifier (number or hash)

Response

200OK

Relay chain metadata at specified version

400Bad Request

Invalid version format

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get metadata by version

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/{version}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/{version}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/{version}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/{version}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/{version}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/{version}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/{version}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/{version}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/runtime/metadata/{version}')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC get runtime spec

GET

https://ksm-playbook.nownodes.io/v1/rc/runtime/spec

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns the runtime spec of the relay chain at a given block.

Parameters

atstringquery

Block identifier (number or hash)

Response

200OK

Relay chain runtime spec

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

RC get runtime spec

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/runtime/spec'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/spec', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/runtime/spec')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/runtime/spec')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/spec', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/runtime/spec";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/runtime/spec', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/runtime/spec')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/runtime/spec')
request = Net::HTTP::Get.new(uri)

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

200

{}

Submit transaction (relay chain)

POST

https://ksm-playbook.nownodes.io/v1/rc/transaction

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Submit a signed extrinsic to the relay chain transaction pool. Only available on parachains.

Body

application/json

Signed extrinsic with 'tx' field containing hex-encoded transaction

object

Response

200OK

Transaction hash

400Bad Request

Invalid transaction

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain not configured

Submit transaction (relay chain)

curl -X POST 'https://ksm-playbook.nownodes.io/v1/rc/transaction' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/rc/transaction', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/transaction";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/rc/transaction', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

Request Body

{}

200

{}

RC dry run transaction

POST

https://ksm-playbook.nownodes.io/v1/rc/transaction/dry-run

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Dry run a transaction on the relay chain.

Body

application/json

Transaction with 'tx', 'senderAddress', and optional 'at' fields

object

Response

200OK

Dry run result

400Bad Request

Invalid transaction

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC dry run transaction

curl -X POST 'https://ksm-playbook.nownodes.io/v1/rc/transaction/dry-run' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/dry-run', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/dry-run')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/rc/transaction/dry-run', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/dry-run', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/transaction/dry-run";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/dry-run', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/rc/transaction/dry-run', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/dry-run')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

Request Body

{}

200

{}

RC fee estimate

POST

https://ksm-playbook.nownodes.io/v1/rc/transaction/fee-estimate

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Estimate the fee for a relay chain transaction.

Body

application/json

Transaction with 'tx' field

object

Response

200OK

Fee estimate

400Bad Request

Invalid transaction

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC fee estimate

curl -X POST 'https://ksm-playbook.nownodes.io/v1/rc/transaction/fee-estimate' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/fee-estimate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/fee-estimate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/rc/transaction/fee-estimate', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/fee-estimate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/transaction/fee-estimate";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/fee-estimate', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/rc/transaction/fee-estimate', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/fee-estimate')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

Request Body

{}

200

{
  "class": "string",
  "partialFee": "string",
  "weight": {
    "proofSize": "string",
    "refTime": "string"
  }
}

RC transaction material

GET

https://ksm-playbook.nownodes.io/v1/rc/transaction/material

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns relay chain network information for transaction construction.

Parameters

atstringquery

Block hash or number to query at

noMetabooleanquery

DEPRECATED: If true, metadata is not included

metadatastringquery

Metadata format: 'json' or 'scale'

Response

200OK

Relay chain transaction material

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC transaction material

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/transaction/material'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/material', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/material')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/transaction/material')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/material', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/transaction/material";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/material', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/transaction/material')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/material')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC transaction material versioned

GET

https://ksm-playbook.nownodes.io/v1/rc/transaction/material/{metadataVersion}

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Returns relay chain transaction material with metadata at a specific version.

Parameters

metadataVersionstringrequiredpath

Metadata version (e.g., 'v14', 'v15')

atstringquery

Block hash or number to query at

noMetabooleanquery

DEPRECATED: If true, metadata is not included

metadatastringquery

Metadata format: 'json' or 'scale'

Response

200OK

Relay chain transaction material with versioned metadata

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC transaction material versioned

curl -X GET 'https://ksm-playbook.nownodes.io/v1/rc/transaction/material/{metadataVersion}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/material/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/material/{metadataVersion}')
request = Net::HTTP::Get.new(uri)

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

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/transaction/material/{metadataVersion}')
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/material/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/transaction/material/{metadataVersion}";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/material/{metadataVersion}', {
  method: 'GET',
});

const data = await response.json();

import requests

response = requests.get('https://ksm-playbook.nownodes.io/v1/rc/transaction/material/{metadataVersion}')
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/material/{metadataVersion}')
request = Net::HTTP::Get.new(uri)

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

200

{}

RC metadata blob

POST

https://ksm-playbook.nownodes.io/v1/rc/transaction/metadata-blob

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Generates a metadata blob from the relay chain for transaction signing.

Body

application/json

Request with 'tx' field and optional 'at' block

object

Response

200OK

Metadata blob

500Internal Server Error

Internal server error

503Service Unavailable

Service unavailable

RC metadata blob

curl -X POST 'https://ksm-playbook.nownodes.io/v1/rc/transaction/metadata-blob' \
  -H 'Content-Type: application/json' \
  -d '{}'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/metadata-blob', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/metadata-blob')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/rc/transaction/metadata-blob', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/metadata-blob', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/transaction/metadata-blob";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/metadata-blob', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

response = requests.post('https://ksm-playbook.nownodes.io/v1/rc/transaction/metadata-blob', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/metadata-blob')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{}'

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

Request Body

{}

200

{}

Parse transaction (relay chain)

POST

https://ksm-playbook.nownodes.io/v1/rc/transaction/parse

Authorizations

ApiKeyAuthApiKeyAuth

api-key string

NOWNodes API key passed in the api-key header.

Decode a raw transaction using relay chain metadata. Only available on parachains. Returns the decoded pallet/method, call arguments, signature info, nonce, tip, era, and hash. Note: This endpoint uses the relay chain's current (latest) metadata for decoding. Transactions created for older runtime versions may fail to decode if the extrinsic format has changed.

Body

application/json

Transaction with 'tx' field containing hex-encoded extrinsic

Request body for transaction parsing.

txstring

Hex-encoded extrinsic with optional 0x prefix.

Response

200OK

Parsed transaction

400Bad Request

Invalid transaction or relay chain not configured

500Internal Server Error

Internal server error

503Service Unavailable

Relay chain unavailable

Parse transaction (relay chain)

curl -X POST 'https://ksm-playbook.nownodes.io/v1/rc/transaction/parse' \
  -H 'Content-Type: application/json' \
  -d '{
    "tx": "0x4902840004316d995f..."
  }'

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/parse', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "tx": "0x4902840004316d995f..."
    }),
});

const data = await response.json();

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/parse')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "tx": "0x4902840004316d995f..."
  }'

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

import requests

payload = {
  "tx": "0x4902840004316d995f..."
}

response = requests.post('https://ksm-playbook.nownodes.io/v1/rc/transaction/parse', json=payload)
data = response.json()

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/parse', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "tx": "0x4902840004316d995f..."
    }),
});

const data = await response.json();

const endpoint = "https://ksm-playbook.nownodes.io/v1/rc/transaction/parse";
const apiKey = "YOUR_API_KEY";

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

  return response.json();
}

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

const response = await fetch('https://ksm-playbook.nownodes.io/v1/rc/transaction/parse', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "tx": "0x4902840004316d995f..."
    }),
});

const data = await response.json();

import requests

payload = {
  "tx": "0x4902840004316d995f..."
}

response = requests.post('https://ksm-playbook.nownodes.io/v1/rc/transaction/parse', json=payload)
data = response.json()

require 'net/http'
require 'json'

uri = URI('https://ksm-playbook.nownodes.io/v1/rc/transaction/parse')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "tx": "0x4902840004316d995f..."
  }'

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

Request Body

{
  "tx": "0x4902840004316d995f..."
}

{
  "args": {},
  "era": {},
  "hash": "0x1234567890abcdef...",
  "isSigned": true,
  "method": {
    "method": "transferAllowDeath",
    "pallet": "balances"
  },
  "nonce": "42",
  "signature": {
    "signature": "0xa24152685f52e4726466e80247d965bb3d349637fc8a1ea6f7cc1451ddec98b5...",
    "signer": {
      "id": "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY"
    }
  },
  "tip": "0"
}

{
  "cause": "string",
  "code": 400,
  "error": "Failed to parse transaction.",
  "stack": "string",
  "transaction": "string"
}

Documentation

How to migrate to NOWNodes

Authentication

NODE

health

Authorizations

Response

node

Authorizations

Response

Authorizations

Parameters

Response

Authorizations

Response

version

Authorizations

Response

blocks

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

Response

Authorizations

Parameters

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

Authorizations

Parameters

Response

Authorizations

Parameters

Response