state_getRuntimeVersion - Bittensor

Example code for the state_getRuntimeVersion JSON-RPC method. Complete guide on how to use state_getRuntimeVersion JSON-RPC in GetBlock Web3 documentation.

Returns the current runtime version — spec_name, spec_version, transaction_version, and authoring_version. Required for constructing signed extrinsics with correct version information.

Substrate native JSON-RPC method. Call against a GetBlock endpoint configured for the Substrate interface. For typed SDK access, use Polkadot.js (TypeScript) or substrateinterface (Python).

Parameters

Parameter	Type	Required	Description
blockHash	string	No	Block hash to query at. Omit for the latest block.

Request Example

cURL

curl --location --request POST 'https://go.getblock.io/<ACCESS-TOKEN>/' \
--header 'Content-Type: application/json' \
--data-raw '{
    "jsonrpc": "2.0",
    "method": "state_getRuntimeVersion",
    "params": [],
    "id": "getblock.io"
}'

JavaScript (Axios)

import axios from 'axios';

const data = JSON.stringify({
    "jsonrpc": "2.0",
    "method": "state_getRuntimeVersion",
    "params": [],
    "id": "getblock.io"
});

const config = {
    method: 'post',
    url: 'https://go.getblock.io/<ACCESS-TOKEN>/',
    headers: {
        'Content-Type': 'application/json'
    },
    data: data
};

axios(config)
    .then(response => console.log(JSON.stringify(response.data, null, 2)))
    .catch(error => console.log(error));

Python (Requests)

import requests
import json

url = "https://go.getblock.io/<ACCESS-TOKEN>/"

payload = json.dumps({
    "jsonrpc": "2.0",
    "method": "state_getRuntimeVersion",
    "params": [],
    "id": "getblock.io"
})

headers = {
    'Content-Type': 'application/json'
}

response = requests.post(url, headers=headers, data=payload)
print(response.text)

Rust (Reqwest)

use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();

    let payload = json!({
        "jsonrpc": "2.0",
        "method": "state_getRuntimeVersion",
        "params": [],
        "id": "getblock.io"
    });

    let response = client
        .post("https://go.getblock.io/<ACCESS-TOKEN>/")
        .header("Content-Type", "application/json")
        .json(&payload)
        .send()
        .await?;

    let result: serde_json::Value = response.json().await?;
    println!("{:#?}", result);

    Ok(())
}

Response Example

{
    "jsonrpc": "2.0",
    "id": "getblock.io",
    "result": {
        "specName": "node-subtensor",
        "implName": "node-subtensor",
        "authoringVersion": 10,
        "specVersion": 224,
        "implVersion": 1,
        "apis": [
            [
                "0xdf6acb689907609b",
                4
            ],
            [
                "0x37e397fc7c91f5e4",
                1
            ]
        ],
        "transactionVersion": 1,
        "stateVersion": 1
    }
}

Response Parameters

Field	Type	Description
result.specName	string	Spec name — node-subtensor for Bittensor
result.specVersion	integer	Spec version — increments with runtime upgrades
result.transactionVersion	integer	Transaction version — must match for signed extrinsics to be accepted
result.apis	array	List of runtime API hash/version pairs
result.stateVersion	integer	State storage version

Use Cases

• Signing extrinsics with correct runtime/transaction version

• Detecting runtime upgrades — specVersion increments on upgrade

• Gating SDK behavior on runtime version (e.g. accessing newly-added pallets)

Error Handling

Status Code	Error Message	Cause
403	Forbidden	Missing or invalid <ACCESS-TOKEN>
-32602	Invalid params	Request parameters are missing or malformed
-32601	Method not found	Method does not exist on this interface — check whether you're calling a Substrate method on an EVM endpoint or vice versa
-32603	Internal error	Server-side error while processing the request
429	Too Many Requests	Rate limit exceeded for your plan

SDK Integration

Polkadot.js (TypeScript)

import { ApiPromise, WsProvider } from '@polkadot/api';

const provider = new WsProvider('wss://go.getblock.io/<ACCESS-TOKEN>/');
const api = await ApiPromise.create({ provider });

// Typed wrapper: api.rpc.state.getRuntimeVersion(...)
const result = await api.rpc.state.getRuntimeVersion();
console.log(result.toHuman());

// Or use the raw RPC interface for any method:
// const raw = await api.rpc.send({ method: 'state_getRuntimeVersion', params: [] });

substrateinterface (Python)

from substrateinterface import SubstrateInterface

substrate = SubstrateInterface(url="wss://go.getblock.io/<ACCESS-TOKEN>/")

# Generic RPC call:
result = substrate.rpc_request("state_getRuntimeVersion", [])
print(result)