Kusama RPC API - State Methods

v1.0.0

Base URL

https://ksm.nownodes.ioKusama RPC

API for interacting with Kusama via JSON-RPC. Contains state category methods for querying runtime storage, metadata, runtime version, and related information.

Authentication

api-keyAuthapiKey

API Key: API_key in header

NODE

state

Retrieve storage for a given key

POST

https://ksm.nownodes.io/state_getStorage

Authorizations

ApiKeyAuthApiKeyAuth

API_key string

NOWNodes API key passed in the api-key header.

Returns the value stored under a specific key at the latest block or a given block.

Body

application/json

JSON-RPC request parameters

jsonrpcstringrequired

JSON-RPC version

idstringrequired

Request identifier

methodstringrequired

Method name

paramsArray<string>required

Array containing storage keys

Response

200OK

Returns the value stored at the specified key

400Bad Request

Malformed address or application ID

401Unauthorized

Invalid API key

500Internal Server Error

Internal server error

Retrieve storage for a given key

curl -X POST 'https://ksm.nownodes.io/state_getStorage' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getStorage",
    "params": [
      "StorageKey"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://ksm.nownodes.io/state_getStorage");
const result = await provider.send("state_getStorage", [
  "StorageKey"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://ksm.nownodes.io/state_getStorage')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "state_getStorage",
  "params": [
    "StorageKey"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://ksm.nownodes.io/state_getStorage"))
response = w3.provider.make_request("state_getStorage", [
  "StorageKey"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://ksm.nownodes.io/state_getStorage"),
});

const result = await client.request({
  method: "state_getStorage",
  params: [
  "StorageKey"
],
});

console.log(result);

const endpoint = "https://ksm.nownodes.io/state_getStorage";
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({ jsonrpc: "2.0", method: "state_getStorage", params: [
  "StorageKey"
], id: 1 });
console.log(result);

const response = await fetch('https://ksm.nownodes.io/state_getStorage', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": "test",
      "method": "state_getStorage",
      "params": [
        "StorageKey"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getStorage",
  "params": [
    "StorageKey"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://ksm.nownodes.io/state_getStorage')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getStorage",
    "params": [
      "StorageKey"
    ]
  }'

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

Request Body

{
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getStorage",
  "params": [
    "StorageKey"
  ]
}

200

{
  "jsonrpc": "2.0",
  "result": "0xf08af92e88010000",
  "id": "test"
}

Get the runtime version

POST

https://ksm.nownodes.io/state_getRuntimeVersion

Authorizations

ApiKeyAuthApiKeyAuth

API_key string

NOWNodes API key passed in the api-key header.

Returns version information about the runtime, including spec version, implementation version, and transaction version.

Body

application/json

JSON-RPC request parameters

jsonrpcstringrequired

JSON-RPC version

idstringrequired

Request identifier

methodstringrequired

Method name

paramsArray<any>required

No parameters required

Response

200OK

Runtime version information

400Bad Request

Malformed address or application ID

401Unauthorized

Invalid API key

500Internal Server Error

Internal server error

Get the runtime version

curl -X POST 'https://ksm.nownodes.io/state_getRuntimeVersion' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getRuntimeVersion",
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://ksm.nownodes.io/state_getRuntimeVersion");
const result = await provider.send("state_getRuntimeVersion", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://ksm.nownodes.io/state_getRuntimeVersion')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "state_getRuntimeVersion",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://ksm.nownodes.io/state_getRuntimeVersion"))
response = w3.provider.make_request("state_getRuntimeVersion", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://ksm.nownodes.io/state_getRuntimeVersion"),
});

const result = await client.request({
  method: "state_getRuntimeVersion",
  params: [],
});

console.log(result);

const endpoint = "https://ksm.nownodes.io/state_getRuntimeVersion";
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({ jsonrpc: "2.0", method: "state_getRuntimeVersion", params: [], id: 1 });
console.log(result);

const response = await fetch('https://ksm.nownodes.io/state_getRuntimeVersion', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": "test",
      "method": "state_getRuntimeVersion",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getRuntimeVersion",
  "params": []
}

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

require 'net/http'
require 'json'

uri = URI('https://ksm.nownodes.io/state_getRuntimeVersion')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getRuntimeVersion",
    "params": []
  }'

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

Request Body

{
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getRuntimeVersion",
  "params": []
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "specName": "kusama",
    "implName": "parity-kusama",
    "authoringVersion": 2,
    "specVersion": 1002000,
    "implVersion": 0,
    "transactionVersion": 25,
    "stateVersion": 1
  },
  "id": "test"
}

Retrieve runtime metadata

POST

https://ksm.nownodes.io/state_getMetadata

Authorizations

ApiKeyAuthApiKeyAuth

API_key string

NOWNodes API key passed in the api-key header.

Returns the runtime metadata, which includes information about modules, calls, storage, and events.

Body

application/json

JSON-RPC request parameters

jsonrpcstringrequired

JSON-RPC version

idstringrequired

Request identifier

methodstringrequired

Method name

paramsArray<any>required

No parameters required

Response

200OK

Runtime metadata in hex format

400Bad Request

Malformed address or application ID

401Unauthorized

Invalid API key

500Internal Server Error

Internal server error

Retrieve runtime metadata

curl -X POST 'https://ksm.nownodes.io/state_getMetadata' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getMetadata",
    "params": []
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://ksm.nownodes.io/state_getMetadata");
const result = await provider.send("state_getMetadata", []);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://ksm.nownodes.io/state_getMetadata')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "state_getMetadata",
  "params": [],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://ksm.nownodes.io/state_getMetadata"))
response = w3.provider.make_request("state_getMetadata", [])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://ksm.nownodes.io/state_getMetadata"),
});

const result = await client.request({
  method: "state_getMetadata",
  params: [],
});

console.log(result);

const endpoint = "https://ksm.nownodes.io/state_getMetadata";
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({ jsonrpc: "2.0", method: "state_getMetadata", params: [], id: 1 });
console.log(result);

const response = await fetch('https://ksm.nownodes.io/state_getMetadata', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": "test",
      "method": "state_getMetadata",
      "params": []
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getMetadata",
  "params": []
}

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

require 'net/http'
require 'json'

uri = URI('https://ksm.nownodes.io/state_getMetadata')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getMetadata",
    "params": []
  }'

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

Request Body

{
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getMetadata",
  "params": []
}

200

{
  "jsonrpc": "2.0",
  "result": "0x6e74696d653e000500485472616e73616374696f6e5061796d656e74...",
  "id": "test"
}

Returns proof of storage entries at a specific block state

POST

https://ksm.nownodes.io/state_getReadProof

Authorizations

ApiKeyAuthApiKeyAuth

API_key string

NOWNodes API key passed in the api-key header.

Provides a cryptographic proof for the existence and content of storage entries at a given block.

Body

application/json

JSON-RPC request parameters

jsonrpcstringrequired

JSON-RPC version

idstringrequired

Request identifier

methodstringrequired

Method name

paramsArray<any>required

List of storage keys for which to generate proof

Response

200OK

Proof of storage entries

400Bad Request

Malformed address or application ID

401Unauthorized

Invalid API key

500Internal Server Error

Internal server error

Returns proof of storage entries at a specific block state

curl -X POST 'https://ksm.nownodes.io/state_getReadProof' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getReadProof",
    "params": [
      "keys: Vec<StorageKey>"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://ksm.nownodes.io/state_getReadProof");
const result = await provider.send("state_getReadProof", [
  "keys: Vec<StorageKey>"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://ksm.nownodes.io/state_getReadProof')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "state_getReadProof",
  "params": [
    "keys: Vec<StorageKey>"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://ksm.nownodes.io/state_getReadProof"))
response = w3.provider.make_request("state_getReadProof", [
  "keys: Vec<StorageKey>"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://ksm.nownodes.io/state_getReadProof"),
});

const result = await client.request({
  method: "state_getReadProof",
  params: [
  "keys: Vec<StorageKey>"
],
});

console.log(result);

const endpoint = "https://ksm.nownodes.io/state_getReadProof";
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({ jsonrpc: "2.0", method: "state_getReadProof", params: [
  "keys: Vec<StorageKey>"
], id: 1 });
console.log(result);

const response = await fetch('https://ksm.nownodes.io/state_getReadProof', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": "test",
      "method": "state_getReadProof",
      "params": [
        "keys: Vec<StorageKey>"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getReadProof",
  "params": [
    "keys: Vec<StorageKey>"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://ksm.nownodes.io/state_getReadProof')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getReadProof",
    "params": [
      "keys: Vec<StorageKey>"
    ]
  }'

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

Request Body

{
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getReadProof",
  "params": [
    "keys: Vec<StorageKey>"
  ]
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "at": "0xabc123blockhash...",
    "proof": [
      "0xproofdata1...",
      "0xproofdata2..."
    ]
  },
  "id": "test"
}

Retrieves the storage hash

POST

https://ksm.nownodes.io/state_getStorageHash

Authorizations

ApiKeyAuthApiKeyAuth

API_key string

NOWNodes API key passed in the api-key header.

Returns the hash of the storage value stored under a specific key.

Body

application/json

JSON-RPC request parameters

jsonrpcstringrequired

idstringrequired

methodstringrequired

paramsArray<any>required

Storage key(s) to compute hash

Response

200OK

Storage hash result

400Bad Request

Malformed address or application ID

401Unauthorized

Invalid API key

500Internal Server Error

Internal server error

Retrieves the storage hash

curl -X POST 'https://ksm.nownodes.io/state_getStorageHash' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getStorageHash",
    "params": [
      "StorageKey"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://ksm.nownodes.io/state_getStorageHash");
const result = await provider.send("state_getStorageHash", [
  "StorageKey"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://ksm.nownodes.io/state_getStorageHash')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "state_getStorageHash",
  "params": [
    "StorageKey"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://ksm.nownodes.io/state_getStorageHash"))
response = w3.provider.make_request("state_getStorageHash", [
  "StorageKey"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://ksm.nownodes.io/state_getStorageHash"),
});

const result = await client.request({
  method: "state_getStorageHash",
  params: [
  "StorageKey"
],
});

console.log(result);

const endpoint = "https://ksm.nownodes.io/state_getStorageHash";
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({ jsonrpc: "2.0", method: "state_getStorageHash", params: [
  "StorageKey"
], id: 1 });
console.log(result);

const response = await fetch('https://ksm.nownodes.io/state_getStorageHash', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": "test",
      "method": "state_getStorageHash",
      "params": [
        "StorageKey"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getStorageHash",
  "params": [
    "StorageKey"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://ksm.nownodes.io/state_getStorageHash')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getStorageHash",
    "params": [
      "StorageKey"
    ]
  }'

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

Request Body

{
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getStorageHash",
  "params": [
    "StorageKey"
  ]
}

200

{
  "jsonrpc": "2.0",
  "result": "0xabc123def4567890...",
  "id": "test"
}

Retrieves the storage size

POST

https://ksm.nownodes.io/state_getStorageSize

Authorizations

ApiKeyAuthApiKeyAuth

API_key string

NOWNodes API key passed in the api-key header.

Returns the size in bytes of the storage value under a specific key.

Body

application/json

JSON-RPC request parameters

jsonrpcstringrequired

idstringrequired

methodstringrequired

paramsArray<any>required

Storage key(s) to measure

Response

200OK

Storage size result

400Bad Request

Malformed address or application ID

401Unauthorized

Invalid API key

500Internal Server Error

Internal server error

Retrieves the storage size

curl -X POST 'https://ksm.nownodes.io/state_getStorageSize' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getStorageSize",
    "params": [
      "StorageKey"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://ksm.nownodes.io/state_getStorageSize");
const result = await provider.send("state_getStorageSize", [
  "StorageKey"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://ksm.nownodes.io/state_getStorageSize')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "state_getStorageSize",
  "params": [
    "StorageKey"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://ksm.nownodes.io/state_getStorageSize"))
response = w3.provider.make_request("state_getStorageSize", [
  "StorageKey"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://ksm.nownodes.io/state_getStorageSize"),
});

const result = await client.request({
  method: "state_getStorageSize",
  params: [
  "StorageKey"
],
});

console.log(result);

const endpoint = "https://ksm.nownodes.io/state_getStorageSize";
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({ jsonrpc: "2.0", method: "state_getStorageSize", params: [
  "StorageKey"
], id: 1 });
console.log(result);

const response = await fetch('https://ksm.nownodes.io/state_getStorageSize', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": "test",
      "method": "state_getStorageSize",
      "params": [
        "StorageKey"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getStorageSize",
  "params": [
    "StorageKey"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://ksm.nownodes.io/state_getStorageSize')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_getStorageSize",
    "params": [
      "StorageKey"
    ]
  }'

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

Request Body

{
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_getStorageSize",
  "params": [
    "StorageKey"
  ]
}

200

{
  "jsonrpc": "2.0",
  "result": "0x0000000000000032",
  "id": "test"
}

Query historical storage entries

POST

https://ksm.nownodes.io/state_queryStorage

Authorizations

ApiKeyAuthApiKeyAuth

API_key string

NOWNodes API key passed in the api-key header.

Returns the storage changes between two blocks for a set of keys.

Body

application/json

JSON-RPC request parameters

jsonrpcstringrequired

idstringrequired

methodstringrequired

paramsArray<any>required

List of storage keys and block range

Response

200OK

Query storage result

400Bad Request

Malformed address or application ID

401Unauthorized

Invalid API key

500Internal Server Error

Internal server error

Query historical storage entries

curl -X POST 'https://ksm.nownodes.io/state_queryStorage' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_queryStorage",
    "params": [
      "StorageKeys",
      "fromBlock",
      "toBlock"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://ksm.nownodes.io/state_queryStorage");
const result = await provider.send("state_queryStorage", [
  "StorageKeys",
  "fromBlock",
  "toBlock"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://ksm.nownodes.io/state_queryStorage')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "state_queryStorage",
  "params": [
    "StorageKeys",
    "fromBlock",
    "toBlock"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://ksm.nownodes.io/state_queryStorage"))
response = w3.provider.make_request("state_queryStorage", [
  "StorageKeys",
  "fromBlock",
  "toBlock"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://ksm.nownodes.io/state_queryStorage"),
});

const result = await client.request({
  method: "state_queryStorage",
  params: [
  "StorageKeys",
  "fromBlock",
  "toBlock"
],
});

console.log(result);

const endpoint = "https://ksm.nownodes.io/state_queryStorage";
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({ jsonrpc: "2.0", method: "state_queryStorage", params: [
  "StorageKeys",
  "fromBlock",
  "toBlock"
], id: 1 });
console.log(result);

const response = await fetch('https://ksm.nownodes.io/state_queryStorage', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": "test",
      "method": "state_queryStorage",
      "params": [
        "StorageKeys",
        "fromBlock",
        "toBlock"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_queryStorage",
  "params": [
    "StorageKeys",
    "fromBlock",
    "toBlock"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://ksm.nownodes.io/state_queryStorage')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_queryStorage",
    "params": [
      "StorageKeys",
      "fromBlock",
      "toBlock"
    ]
  }'

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

Request Body

{
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_queryStorage",
  "params": [
    "StorageKeys",
    "fromBlock",
    "toBlock"
  ]
}

200

{
  "jsonrpc": "2.0",
  "result": {
    "block": "0x298f8c5f8572a869abe215216c0b12b255bc325407dd115b410dd0224418baa4",
    "changes": [
      [
        "0x26aa394eea5630e07c48ae0c9558cef7",
        "0x0000000000000000000000000000000000000000000000000000000000000000"
      ]
    ]
  },
  "id": "test"
}

Query storage entries at a specific block

POST

https://ksm.nownodes.io/state_queryStorageAt

Authorizations

ApiKeyAuthApiKeyAuth

API_key string

NOWNodes API key passed in the api-key header.

Returns the storage values for given keys at a specified block hash.

Body

application/json

JSON-RPC request parameters

jsonrpcstringrequired

idstringrequired

methodstringrequired

paramsArray<any>required

List of storage keys and block hash

Response

200OK

Storage entries at block

400Bad Request

Malformed address or application ID

401Unauthorized

Invalid API key

500Internal Server Error

Internal server error

Query storage entries at a specific block

curl -X POST 'https://ksm.nownodes.io/state_queryStorageAt' \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_queryStorageAt",
    "params": [
      "StorageKeys",
      "fromBlock"
    ]
  }'

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider("https://ksm.nownodes.io/state_queryStorageAt");
const result = await provider.send("state_queryStorageAt", [
  "StorageKeys",
  "fromBlock"
]);
console.log(result);

require 'eth'
require 'json'
require 'net/http'

uri = URI('https://ksm.nownodes.io/state_queryStorageAt')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
  "jsonrpc": "2.0",
  "method": "state_queryStorageAt",
  "params": [
    "StorageKeys",
    "fromBlock"
  ],
  "id": 1
}'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://ksm.nownodes.io/state_queryStorageAt"))
response = w3.provider.make_request("state_queryStorageAt", [
  "StorageKeys",
  "fromBlock"
])
print(response)

import { createPublicClient, http } from "viem";

const client = createPublicClient({
  transport: http("https://ksm.nownodes.io/state_queryStorageAt"),
});

const result = await client.request({
  method: "state_queryStorageAt",
  params: [
  "StorageKeys",
  "fromBlock"
],
});

console.log(result);

const endpoint = "https://ksm.nownodes.io/state_queryStorageAt";
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({ jsonrpc: "2.0", method: "state_queryStorageAt", params: [
  "StorageKeys",
  "fromBlock"
], id: 1 });
console.log(result);

const response = await fetch('https://ksm.nownodes.io/state_queryStorageAt', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
      "jsonrpc": "2.0",
      "id": "test",
      "method": "state_queryStorageAt",
      "params": [
        "StorageKeys",
        "fromBlock"
      ]
    }),
});

const data = await response.json();

import requests

payload = {
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_queryStorageAt",
  "params": [
    "StorageKeys",
    "fromBlock"
  ]
}

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

require 'net/http'
require 'json'

uri = URI('https://ksm.nownodes.io/state_queryStorageAt')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = '{
    "jsonrpc": "2.0",
    "id": "test",
    "method": "state_queryStorageAt",
    "params": [
      "StorageKeys",
      "fromBlock"
    ]
  }'

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

Request Body

{
  "jsonrpc": "2.0",
  "id": "test",
  "method": "state_queryStorageAt",
  "params": [
    "StorageKeys",
    "fromBlock"
  ]
}

200

{
  "jsonrpc": "2.0",
  "result": [
    [
      "0x26aa394eea5630e07c48ae0c9558cef7",
      "0x0000000000000000000000000000000000000000000000000000000000000000"
    ]
  ],
  "id": "test"
}

Documentation

How to migrate to NOWNodes

Kusama RPC API - State Methods

Authentication

NODE

state

Retrieve storage for a given key

Authorizations

Body

Response

Get the runtime version

Authorizations

Body

Response

Retrieve runtime metadata

Authorizations

Body

Response

Returns proof of storage entries at a specific block state

Authorizations

Body

Response

Retrieves the storage hash

Authorizations

Body

Response

Retrieves the storage size

Authorizations

Body

Response

Query historical storage entries

Authorizations

Body

Response

Query storage entries at a specific block

Authorizations

Body

Response