Skip to main content
SUBMIT A PRSUBMIT AN ISSUElast edit: May 07, 2026

RPC

This page shows JSON-RPC methods available on a Bittensor (Subtensor) node. Accessible via api.rpc.<namespace>.<method_name>.

info

Generated from a live snapshot of the Subtensor runtime on 2026-04-24. Connected to: wss://entrypoint-finney.opentensor.ai:443

subtensorModule (Runtime API)​

These methods are exposed via the Subtensor Runtime API and are accessed through api.call.subtensorModuleRuntimeApi.* rather than api.rpc.*.

getHotkeyConviction(hotkey: AccountId32, netuid: NetUid): U64F64​

  • interface: api.call.subtensorModuleRuntimeApi.getHotkeyConviction
  • summary: Returns the current total conviction for hotkey on netuid, aggregated over all coldkeys that have locked to this hotkey. Conviction grows exponentially toward the total locked mass with a time constant of ≈90 days. See Conviction Staking.

getMostConvictedHotkeyOnSubnet(netuid: NetUid): Option<AccountId32>​

  • interface: api.call.subtensorModuleRuntimeApi.getMostConvictedHotkeyOnSubnet
  • summary: Returns the hotkey with the highest total conviction on netuid, or None if no locks exist on the subnet. Conviction is evaluated at the current block (rolled forward lazily). See Conviction Staking.

author​

hasKey(publicKey: Bytes, keyType: Text): bool​

  • interface: api.rpc.author.hasKey
  • unsafe: this method is flagged as unsafe
  • summary: Returns true if the keystore has private keys for the given public key and key type.

hasSessionKeys(sessionKeys: Bytes): bool​

  • interface: api.rpc.author.hasSessionKeys
  • unsafe: this method is flagged as unsafe
  • summary: Returns true if the keystore has private keys for the given session public keys.

insertKey(keyType: Text, suri: Text, publicKey: Bytes): Bytes​

  • interface: api.rpc.author.insertKey
  • unsafe: this method is flagged as unsafe
  • summary: Insert a key into the keystore.

pendingExtrinsics(): Vec<Extrinsic>​

  • interface: api.rpc.author.pendingExtrinsics
  • summary: Returns all pending extrinsics, potentially grouped by sender

removeExtrinsic(bytesOrHash: Vec<ExtrinsicOrHash>): Vec<Hash>​

  • interface: api.rpc.author.removeExtrinsic
  • unsafe: this method is flagged as unsafe
  • summary: Remove given extrinsic from the pool and temporarily ban it to prevent reimporting

rotateKeys(): Bytes​

  • interface: api.rpc.author.rotateKeys
  • unsafe: this method is flagged as unsafe
  • summary: Generate new session keys and returns the corresponding public keys

submitAndWatchExtrinsic(extrinsic: Extrinsic): ExtrinsicStatus​

  • interface: api.rpc.author.submitAndWatchExtrinsic
  • jsonrpc: subscription
  • summary: Submit and subscribe to watch an extrinsic until unsubscribed

submitExtrinsic(extrinsic: Extrinsic): Hash​

  • interface: api.rpc.author.submitExtrinsic
  • summary: Submit a fully formatted extrinsic for block inclusion

chain​

getBlock(hash?: BlockHash): SignedBlock​

  • interface: api.rpc.chain.getBlock
  • summary: Get header and body of a relay chain block

getBlockHash(blockNumber?: BlockNumber): BlockHash​

  • interface: api.rpc.chain.getBlockHash
  • summary: Get the block hash for a specific block

getFinalizedHead(): BlockHash​

  • interface: api.rpc.chain.getFinalizedHead
  • summary: Get hash of the last finalized block in the canon chain

getHeader(hash?: BlockHash): Header​

  • interface: api.rpc.chain.getHeader
  • summary: Retrieves the header for a specific block

subscribeAllHeads(): Header​

  • interface: api.rpc.chain.subscribeAllHeads
  • jsonrpc: subscription
  • summary: Retrieves the newest header via subscription

subscribeFinalizedHeads(): Header​

  • interface: api.rpc.chain.subscribeFinalizedHeads
  • jsonrpc: subscription
  • summary: Retrieves the best finalized header via subscription

subscribeNewHeads(): Header​

  • interface: api.rpc.chain.subscribeNewHeads
  • jsonrpc: subscription
  • summary: Retrieves the best header via subscription

childstate​

getKeys(childKey: PrefixedStorageKey, prefix: StorageKey, at?: Hash): Vec<StorageKey>​

  • interface: api.rpc.childstate.getKeys
  • summary: Returns the keys with prefix from a child storage, leave empty to get all the keys

getKeysPaged(childKey: PrefixedStorageKey, prefix: StorageKey, count: u32, startKey?: StorageKey, at?: Hash): Vec<StorageKey>​

  • interface: api.rpc.childstate.getKeysPaged
  • summary: Returns the keys with prefix from a child storage with pagination support

getStorage(childKey: PrefixedStorageKey, key: StorageKey, at?: Hash): Option<StorageData>​

  • interface: api.rpc.childstate.getStorage
  • summary: Returns a child storage entry at a specific block state

getStorageEntries(childKey: PrefixedStorageKey, keys: Vec<StorageKey>, at?: Hash): Vec<Option<StorageData>>​

  • interface: api.rpc.childstate.getStorageEntries
  • summary: Returns child storage entries for multiple keys at a specific block state

getStorageHash(childKey: PrefixedStorageKey, key: StorageKey, at?: Hash): Option<Hash>​

  • interface: api.rpc.childstate.getStorageHash
  • summary: Returns the hash of a child storage entry at a block state

getStorageSize(childKey: PrefixedStorageKey, key: StorageKey, at?: Hash): Option<u64>​

  • interface: api.rpc.childstate.getStorageSize
  • summary: Returns the size of a child storage entry at a block state

eth​

accounts(): Vec<H160>​

  • interface: api.rpc.eth.accounts
  • summary: Returns accounts list.

blockNumber(): U256​

  • interface: api.rpc.eth.blockNumber
  • summary: Returns the blockNumber

call(request: EthCallRequest, number?: BlockNumber): Bytes​

  • interface: api.rpc.eth.call
  • summary: Call contract, returning the output data.

chainId(): U64​

  • interface: api.rpc.eth.chainId
  • summary: Returns the chain ID used for transaction signing at the current best block. None is returned if not available.

coinbase(): H160​

  • interface: api.rpc.eth.coinbase
  • summary: Returns block author.

estimateGas(request: EthCallRequest, number?: BlockNumber): U256​

  • interface: api.rpc.eth.estimateGas
  • summary: Estimate gas needed for execution of given contract.

feeHistory(blockCount: U256, newestBlock: BlockNumber, rewardPercentiles: Option<Vec<f64>>): EthFeeHistory​

  • interface: api.rpc.eth.feeHistory
  • summary: Returns fee history for given block count & reward percentiles

gasPrice(): U256​

  • interface: api.rpc.eth.gasPrice
  • summary: Returns current gas price.

getBalance(address: H160, number?: BlockNumber): U256​

  • interface: api.rpc.eth.getBalance
  • summary: Returns balance of the given account.

getBlockByHash(hash: H256, full: bool): Option<EthRichBlock>​

  • interface: api.rpc.eth.getBlockByHash
  • summary: Returns block with given hash.

getBlockByNumber(block: BlockNumber, full: bool): Option<EthRichBlock>​

  • interface: api.rpc.eth.getBlockByNumber
  • summary: Returns block with given number.

getBlockTransactionCountByHash(hash: H256): U256​

  • interface: api.rpc.eth.getBlockTransactionCountByHash
  • summary: Returns the number of transactions in a block with given hash.

getBlockTransactionCountByNumber(block: BlockNumber): U256​

  • interface: api.rpc.eth.getBlockTransactionCountByNumber
  • summary: Returns the number of transactions in a block with given block number.

getCode(address: H160, number?: BlockNumber): Bytes​

  • interface: api.rpc.eth.getCode
  • summary: Returns the code at given address at given time (block number).

getFilterChanges(index: U256): EthFilterChanges​

  • interface: api.rpc.eth.getFilterChanges
  • summary: Returns filter changes since last poll.

getFilterLogs(index: U256): Vec<EthLog>​

  • interface: api.rpc.eth.getFilterLogs
  • summary: Returns all logs matching given filter (in a range 'from' - 'to').

getLogs(filter: EthFilter): Vec<EthLog>​

  • interface: api.rpc.eth.getLogs
  • summary: Returns logs matching given filter object.

getStorageAt(address: H160, index: U256, number?: BlockNumber): H256​

  • interface: api.rpc.eth.getStorageAt
  • summary: Returns content of the storage at given address.

getTransactionByBlockHashAndIndex(hash: H256, index: U256): EthTransaction​

  • interface: api.rpc.eth.getTransactionByBlockHashAndIndex
  • summary: Returns transaction at given block hash and index.

getTransactionByBlockNumberAndIndex(number: BlockNumber, index: U256): EthTransaction​

  • interface: api.rpc.eth.getTransactionByBlockNumberAndIndex
  • summary: Returns transaction by given block number and index.

getTransactionByHash(hash: H256): EthTransaction​

  • interface: api.rpc.eth.getTransactionByHash
  • summary: Get transaction by its hash.

getTransactionCount(address: H160, number?: BlockNumber): U256​

  • interface: api.rpc.eth.getTransactionCount
  • summary: Returns the number of transactions sent from given address at given time (block number).

getTransactionReceipt(hash: H256): EthReceipt​

  • interface: api.rpc.eth.getTransactionReceipt
  • summary: Returns transaction receipt by transaction hash.

getUncleByBlockHashAndIndex(hash: H256, index: U256): EthRichBlock​

  • interface: api.rpc.eth.getUncleByBlockHashAndIndex
  • summary: Returns an uncles at given block and index.

getUncleByBlockNumberAndIndex(number: BlockNumber, index: U256): EthRichBlock​

  • interface: api.rpc.eth.getUncleByBlockNumberAndIndex
  • summary: Returns an uncles at given block and index.

getUncleCountByBlockHash(hash: H256): U256​

  • interface: api.rpc.eth.getUncleCountByBlockHash
  • summary: Returns the number of uncles in a block with given hash.

getUncleCountByBlockNumber(number: BlockNumber): U256​

  • interface: api.rpc.eth.getUncleCountByBlockNumber
  • summary: Returns the number of uncles in a block with given block number.

getWork(): EthWork​

  • interface: api.rpc.eth.getWork
  • summary: Returns the hash of the current block, the seedHash, and the boundary condition to be met.

hashrate(): U256​

  • interface: api.rpc.eth.hashrate
  • summary: Returns the number of hashes per second that the node is mining with.

maxPriorityFeePerGas(): U256​

  • interface: api.rpc.eth.maxPriorityFeePerGas
  • summary: Returns max priority fee per gas

mining(): bool​

  • interface: api.rpc.eth.mining
  • summary: Returns true if client is actively mining new blocks.

newBlockFilter(): U256​

  • interface: api.rpc.eth.newBlockFilter
  • summary: Returns id of new block filter.

newFilter(filter: EthFilter): U256​

  • interface: api.rpc.eth.newFilter
  • summary: Returns id of new filter.

newPendingTransactionFilter(): U256​

  • interface: api.rpc.eth.newPendingTransactionFilter
  • summary: Returns id of new block filter.

protocolVersion(): u64​

  • interface: api.rpc.eth.protocolVersion
  • summary: Returns protocol version encoded as a string (quotes are necessary).

sendRawTransaction(bytes: Bytes): H256​

  • interface: api.rpc.eth.sendRawTransaction
  • summary: Sends signed transaction, returning its hash.

sendTransaction(tx: EthTransactionRequest): H256​

  • interface: api.rpc.eth.sendTransaction
  • summary: Sends transaction; will block waiting for signer to return the transaction hash

submitHashrate(index: U256, hash: H256): bool​

  • interface: api.rpc.eth.submitHashrate
  • summary: Used for submitting mining hashrate.

submitWork(nonce: H64, headerHash: H256, mixDigest: H256): bool​

  • interface: api.rpc.eth.submitWork
  • summary: Used for submitting a proof-of-work solution.

subscribe(kind: EthSubKind, params?: EthSubParams): Null​

  • interface: api.rpc.eth.subscribe
  • jsonrpc: subscription
  • summary: Subscribe to Eth subscription.

syncing(): EthSyncStatus​

  • interface: api.rpc.eth.syncing
  • summary: Returns an object with data about the sync status or false.

uninstallFilter(index: U256): bool​

  • interface: api.rpc.eth.uninstallFilter
  • summary: Uninstalls filter.

net​

listening(): bool​

  • interface: api.rpc.net.listening
  • summary: Returns true if client is actively listening for network connections. Otherwise false.

peerCount(): Text​

  • interface: api.rpc.net.peerCount
  • summary: Returns number of peers connected to node.

version(): Text​

  • interface: api.rpc.net.version
  • summary: Returns protocol version.

offchain​

localStorageGet(kind: StorageKind, key: Bytes): Option<Bytes>​

  • interface: api.rpc.offchain.localStorageGet
  • unsafe: this method is flagged as unsafe
  • summary: Get offchain local storage under given key and prefix

localStorageSet(kind: StorageKind, key: Bytes, value: Bytes): Null​

  • interface: api.rpc.offchain.localStorageSet
  • unsafe: this method is flagged as unsafe
  • summary: Set offchain local storage under given key and prefix

payment​

queryFeeDetails(extrinsic: Bytes, at?: BlockHash): FeeDetails​

  • interface: api.rpc.payment.queryFeeDetails
  • summary: Query the detailed fee of a given encoded extrinsic

queryInfo(extrinsic: Bytes, at?: BlockHash): RuntimeDispatchInfoV1​

  • interface: api.rpc.payment.queryInfo
  • summary: Retrieves the fee information for an encoded extrinsic

rpc​

methods(): RpcMethods​

  • interface: api.rpc.rpc.methods
  • summary: Retrieves the list of RPC methods that are exposed by the node

state​

call(method: Text, data: Bytes, at?: BlockHash): Bytes​

  • interface: api.rpc.state.call
  • summary: Perform a call to a builtin on the chain

getChildReadProof(childStorageKey: PrefixedStorageKey, keys: Vec<StorageKey>, at?: BlockHash): ReadProof​

  • interface: api.rpc.state.getChildReadProof
  • summary: Returns proof of storage for child key entries at a specific block state.

getKeys(key: StorageKey, at?: BlockHash): Vec<StorageKey>​

  • interface: api.rpc.state.getKeys
  • summary: Retrieves the keys with a certain prefix

getKeysPaged(key: StorageKey, count: u32, startKey?: StorageKey, at?: BlockHash): Vec<StorageKey>​

  • interface: api.rpc.state.getKeysPaged
  • summary: Returns the keys with prefix with pagination support.

getMetadata(at?: BlockHash): Metadata​

  • interface: api.rpc.state.getMetadata
  • summary: Returns the runtime metadata

getPairs(prefix: StorageKey, at?: BlockHash): Vec<KeyValue>​

  • interface: api.rpc.state.getPairs
  • unsafe: this method is flagged as unsafe
  • summary: Returns the keys with prefix, leave empty to get all the keys (deprecated: Use getKeysPaged)

getReadProof(keys: Vec<StorageKey>, at?: BlockHash): ReadProof​

  • interface: api.rpc.state.getReadProof
  • summary: Returns proof of storage entries at a specific block state

getRuntimeVersion(at?: BlockHash): RuntimeVersion​

  • interface: api.rpc.state.getRuntimeVersion
  • summary: Get the runtime version

getStorage(key: StorageKey, at?: BlockHash): StorageData​

  • interface: api.rpc.state.getStorage
  • summary: Retrieves the storage for a key

getStorageHash(key: StorageKey, at?: BlockHash): Hash​

  • interface: api.rpc.state.getStorageHash
  • summary: Retrieves the storage hash

getStorageSize(key: StorageKey, at?: BlockHash): u64​

  • interface: api.rpc.state.getStorageSize
  • summary: Retrieves the storage size

queryStorage(keys: Vec<StorageKey>, fromBlock: Hash, toBlock?: BlockHash): Vec<StorageChangeSet>​

  • interface: api.rpc.state.queryStorage
  • unsafe: this method is flagged as unsafe
  • summary: Query historical storage entries (by key) starting from a start block

queryStorageAt(keys: Vec<StorageKey>, at?: BlockHash): Vec<StorageChangeSet>​

  • interface: api.rpc.state.queryStorageAt
  • summary: Query storage entries (by key) starting at block hash given as the second parameter

subscribeRuntimeVersion(): RuntimeVersion​

  • interface: api.rpc.state.subscribeRuntimeVersion
  • jsonrpc: subscription
  • summary: Retrieves the runtime version via subscription

subscribeStorage(keys?: Vec<StorageKey>): StorageChangeSet​

  • interface: api.rpc.state.subscribeStorage
  • jsonrpc: subscription
  • summary: Subscribes to storage changes for the provided keys

traceBlock(block: Hash, targets: Option<Text>, storageKeys: Option<Text>, methods: Option<Text>): TraceBlockResponse​

  • interface: api.rpc.state.traceBlock
  • unsafe: this method is flagged as unsafe
  • summary: Provides a way to trace the re-execution of a single block

system​

accountNextIndex(accountId: AccountId): Index​

  • interface: api.rpc.system.accountNextIndex
  • summary: Retrieves the next accountIndex as available on the node

addLogFilter(directives: Text): Null​

  • interface: api.rpc.system.addLogFilter
  • unsafe: this method is flagged as unsafe
  • summary: Adds the supplied directives to the current log filter

addReservedPeer(peer: Text): Text​

  • interface: api.rpc.system.addReservedPeer
  • unsafe: this method is flagged as unsafe
  • summary: Adds a reserved peer

chain(): Text​

  • interface: api.rpc.system.chain
  • summary: Retrieves the chain

chainType(): ChainType​

  • interface: api.rpc.system.chainType
  • summary: Retrieves the chain type

dryRun(extrinsic: Bytes, at?: BlockHash): ApplyExtrinsicResult​

  • interface: api.rpc.system.dryRun
  • unsafe: this method is flagged as unsafe
  • summary: Dry run an extrinsic at a given block

health(): Health​

  • interface: api.rpc.system.health
  • summary: Return health status of the node

localListenAddresses(): Vec<Text>​

  • interface: api.rpc.system.localListenAddresses
  • summary: The addresses include a trailing /p2p/ with the local PeerId, and are thus suitable to be passed to addReservedPeer or as a bootnode address for example

localPeerId(): Text​

  • interface: api.rpc.system.localPeerId
  • summary: Returns the base58-encoded PeerId of the node

name(): Text​

  • interface: api.rpc.system.name
  • summary: Retrieves the node name

networkState(): NetworkState​

  • interface: api.rpc.system.networkState
  • unsafe: this method is flagged as unsafe
  • summary: Returns current state of the network

nodeRoles(): Vec<NodeRole>​

  • interface: api.rpc.system.nodeRoles
  • summary: Returns the roles the node is running as

peers(): Vec<PeerInfo>​

  • interface: api.rpc.system.peers
  • unsafe: this method is flagged as unsafe
  • summary: Returns the currently connected peers

properties(): ChainProperties​

  • interface: api.rpc.system.properties
  • summary: Get a custom set of properties as a JSON object, defined in the chain spec

removeReservedPeer(peerId: Text): Text​

  • interface: api.rpc.system.removeReservedPeer
  • unsafe: this method is flagged as unsafe
  • summary: Remove a reserved peer

reservedPeers(): Vec<Text>​

  • interface: api.rpc.system.reservedPeers
  • summary: Returns the list of reserved peers

resetLogFilter(): Null​

  • interface: api.rpc.system.resetLogFilter
  • unsafe: this method is flagged as unsafe
  • summary: Resets the log filter to Substrate defaults

syncState(): SyncState​

  • interface: api.rpc.system.syncState
  • summary: Returns the state of the syncing of the node

version(): Text​

  • interface: api.rpc.system.version
  • summary: Retrieves the version of the node

web3​

clientVersion(): Text​

  • interface: api.rpc.web3.clientVersion
  • summary: Returns current client version.

sha3(data: Bytes): H256​

  • interface: api.rpc.web3.sha3
  • summary: Returns sha3 of the given data