rpc_methods - JSON-RPC Method

Description

Returns a list of all available JSON-RPC methods that the Polkadot node supports. This method is useful for discovering API capabilities, checking method availability, and debugging connectivity issues.

Parameters

This method does not require any parameters.

Returns

Field	Type	Description
methods	array	Array of strings listing all available RPC method names

Request Example

{
  "jsonrpc": "2.0",
  "method": "rpc_methods",
  "params": [],
  "id": 1
}

Response Example

{
  "jsonrpc": "2.0",
  "result": {
    "methods": [
      "author_pendingExtrinsics",
      "author_submitAndWatchExtrinsic",
      "author_submitExtrinsic",
      "author_unwatchExtrinsic",
      "beefy_getFinalizedHead",
      "beefy_subscribeJustifications",
      "beefy_unsubscribeJustifications",
      "chain_getBlock",
      "chain_getBlockHash",
      "chain_getFinalizedHead",
      "chain_getHeader",
      "chain_subscribeAllHeads",
      "chain_subscribeFinalizedHeads",
      "chain_subscribeNewHeads",
      "chain_subscribeRuntimeVersion",
      "chain_unsubscribeAllHeads",
      "chain_unsubscribeFinalizedHeads",
      "chain_unsubscribeNewHeads",
      "chain_unsubscribeRuntimeVersion",
      "childstate_getKeys",
      "childstate_getKeysPaged",
      "childstate_getStorage",
      "childstate_getStorageEntries",
      "childstate_getStorageHash",
      "childstate_getStorageSize",
      "grandpa_proveFinality",
      "grandpa_roundState",
      "grandpa_subscribeJustifications",
      "grandpa_unsubscribeJustifications",
      "offchain_localStorageGet",
      "offchain_localStorageSet",
      "payment_queryFeeDetails",
      "payment_queryInfo",
      "rpc_methods",
      "state_call",
      "state_getChildReadProof",
      "state_getKeysPaged",
      "state_getMetadata",
      "state_getPairs",
      "state_getReadProof",
      "state_getRuntimeVersion",
      "state_getStorage",
      "state_getStorageHash",
      "state_getStorageSize",
      "state_queryStorage",
      "state_queryStorageAt",
      "state_subscribeRuntimeVersion",
      "state_subscribeStorage",
      "state_traceBlock",
      "state_trieMigrationStatus",
      "state_unsubscribeRuntimeVersion",
      "state_unsubscribeStorage",
      "sync_state_genSyncSpec",
      "system_accountNextIndex",
      "system_addReservedPeer",
      "system_chain",
      "system_chainType",
      "system_dryRun",
      "system_health",
      "system_localListenAddresses",
      "system_localPeerId",
      "system_name",
      "system_nodeRoles",
      "system_peers",
      "system_properties",
      "system_removeReservedPeer",
      "system_syncState",
      "system_version"
    ]
  },
  "id": 1
}

Code Examples

JavaScript

const getAvailableMethods = async () => {
  const response = await fetch('https://api-asset-hub-polkadot.n.dwellir.com', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      method: 'rpc_methods',
      params: [],
      id: 1
    })
  });
  
  const data = await response.json();
  return data.result.methods;
};

// Check available methods
const methods = await getAvailableMethods();
console.log(`Total methods available: ${methods.length}`);

// Group methods by namespace
const methodsByNamespace = methods.reduce((acc, method) => {
  const [namespace] = method.split('_');
  if (!acc[namespace]) acc[namespace] = [];
  acc[namespace].push(method);
  return acc;
}, {});

console.log('Methods by namespace:', methodsByNamespace);

// Check if specific method is available
const hasMethod = (methodName) => methods.includes(methodName);
console.log('Has author_submitExtrinsic:', hasMethod('author_submitExtrinsic'));

Python

import requests
import json
from collections import defaultdict

def get_rpc_methods():
    url = "https://api-asset-hub-polkadot.n.dwellir.com"
    headers = {
        "Content-Type": "application/json"
    }
    
    payload = {
        "jsonrpc": "2.0",
        "method": "rpc_methods",
        "params": [],
        "id": 1
    }
    
    response = requests.post(url, headers=headers, data=json.dumps(payload))
    data = response.json()
    
    if "error" in data:
        raise Exception(f"RPC Error: {data['error']}")
    
    return data["result"]["methods"]

# Get and analyze methods
methods = get_rpc_methods()
print(f"Total methods: {len(methods)}")

# Group by namespace
namespaces = defaultdict(list)
for method in methods:
    namespace = method.split('_')[0]
    namespaces[namespace].append(method)

# Display namespace summary
for namespace, methods_list in sorted(namespaces.items()):
    print(f"{namespace}: {len(methods_list)} methods")
    
# Check for specific capabilities
subscription_methods = [m for m in methods if 'subscribe' in m]
print(f"\nSubscription methods: {len(subscription_methods)}")

Method Categories

Core Namespaces

Namespace	Description	Example Methods
author	Transaction submission	submitExtrinsic, pendingExtrinsics
chain	Blockchain queries	getBlock, getBlockHash
state	State queries	getStorage, getMetadata
system	Node information	health, version, chain

Specialized Namespaces

Namespace	Description	Example Methods
beefy	BEEFY consensus	getFinalizedHead
grandpa	GRANDPA finality	roundState, proveFinality
childstate	Child trie queries	getStorage, getKeys
payment	Fee calculation	queryInfo, queryFeeDetails
offchain	Offchain storage	localStorageGet, localStorageSet
sync	Sync operations	state_genSyncSpec

Method Availability Check

class RPCCapabilities {
  constructor(methods) {
    this.methods = new Set(methods);
    this.namespaces = this.groupByNamespace(methods);
  }
  
  groupByNamespace(methods) {
    const namespaces = {};
    methods.forEach(method => {
      const [ns] = method.split('_');
      if (!namespaces[ns]) namespaces[ns] = new Set();
      namespaces[ns].add(method);
    });
    return namespaces;
  }
  
  hasMethod(method) {
    return this.methods.has(method);
  }
  
  hasNamespace(namespace) {
    return namespace in this.namespaces;
  }
  
  requireMethods(required) {
    const missing = required.filter(m => !this.hasMethod(m));
    if (missing.length > 0) {
      throw new Error(`Missing required methods: ${missing.join(', ')}`);
    }
    return true;
  }
  
  getSubscriptionMethods() {
    return Array.from(this.methods).filter(m => 
      m.includes('subscribe') || m.includes('unsubscribe')
    );
  }
  
  supportsWebSocket() {
    return this.getSubscriptionMethods().length > 0;
  }
}

// Usage
const methods = await getAvailableMethods();
const capabilities = new RPCCapabilities(methods);

// Check capabilities
console.log('Supports WebSocket:', capabilities.supportsWebSocket());
console.log('Has GRANDPA:', capabilities.hasNamespace('grandpa'));

// Require specific methods
try {
  capabilities.requireMethods([
    'chain_getBlock',
    'author_submitExtrinsic',
    'state_getMetadata'
  ]);
  console.log('All required methods available');
} catch (error) {
  console.error(error.message);
}

Use Cases

1. API Discovery: Explore available functionality
2. Capability Detection: Check if specific features are available
3. Version Compatibility: Verify method availability across versions
4. Client Configuration: Configure clients based on available methods
5. Documentation: Generate API documentation dynamically

Notes

• Method list may vary based on node configuration
• Some methods require specific node flags to be enabled
• Subscription methods only work over WebSocket connections
• Custom chains may have additional or different methods
• Use this to verify node capabilities before making calls

Related Methods

• state_getRuntimeVersion - Get runtime version
• system_chain - Get chain name
• system_health - Get node health
• state_getMetadata - Get runtime metadata