neuronInfo_getNeuron - Bittensor RPC Method

import requests
import json

url = 'https://api-bittensor-mainnet.n.dwellir.com/YOUR_API_KEY'

# Fetch neuron info for UID 0 in subnet 1
payload = {
    'jsonrpc': '2.0',
    'method': 'neuronInfo_getNeuron',
    'params': [1, 0, None],
    'id': 1
}

response = requests.post(url, json=payload)
result = response.json()

if result.get('result'):
    scale_bytes = result['result']
    print(f'Neuron info SCALE data size: {len(scale_bytes)} bytes')
else:
    print('No neuron found at this UID')

# To decode with bittensor SDK:
# import bittensor as bt
# sub = bt.subtensor(network='finney')
# neuron = sub.neuron_for_uid(uid=0, netuid=1)
# print(f"Hotkey: {neuron.hotkey}")
# print(f"Stake: {neuron.stake:.4f} TAO")
# print(f"Trust: {neuron.trust:.4f}")
# print(f"Incentive: {neuron.incentive:.4f}")
# print(f"Emission: {neuron.emission:.4f} TAO/tempo")

import bittensor as bt
import socket
import struct

sub = bt.subtensor(network='finney')

# Detailed neuron inspection
netuid = 1
uid = 0
neuron = sub.neuron_for_uid(uid=uid, netuid=netuid)

print(f"=== Neuron UID {uid} on Subnet {netuid} ===")
print(f"Hotkey:  {neuron.hotkey}")
print(f"Coldkey: {neuron.coldkey}")
print(f"Active:  {neuron.active}")

# Role identification
role = "Validator" if neuron.validator_permit else "Miner"
print(f"Role:    {role}")

# Performance scores
print(f"\n--- Performance ---")
print(f"Trust:           {neuron.trust:.4f}")
print(f"Consensus:       {neuron.consensus:.4f}")
print(f"Incentive:       {neuron.incentive:.4f}")
print(f"Dividends:       {neuron.dividends:.4f}")
print(f"Rank:            {neuron.rank:.4f}")
print(f"Validator Trust: {neuron.validator_trust:.4f}")
print(f"Pruning Score:   {neuron.pruning_score:.4f}")

# Stake breakdown
print(f"\n--- Stake ---")
total_stake = sum(amount.tao for _, amount in neuron.stake)
print(f"Total stake: {total_stake:,.2f} TAO ({len(neuron.stake)} stake entries)")
for coldkey, amount in sorted(neuron.stake, key=lambda x: x[1], reverse=True)[:5]:
    pct = (amount.tao / total_stake * 100) if total_stake > 0 else 0
    print(f"  {coldkey[:18]}.. : {amount.tao:>12,.2f} TAO ({pct:.1f}%)")

# Emissions
print(f"\n--- Emissions ---")
print(f"Emission per tempo: {neuron.emission:.6f} TAO")

# Weight analysis (for validators)
if neuron.validator_permit and neuron.weights:
    print(f"\n--- Weights (top 10) ---")
    sorted_weights = sorted(neuron.weights, key=lambda x: x[1], reverse=True)
    for target_uid, weight in sorted_weights[:10]:
        print(f"  -> UID {target_uid}: weight={weight / 65535:.4f}")

# Network endpoint
if neuron.axon_info.ip != 0:
    ip_bytes = neuron.axon_info.ip.to_bytes(16, 'big')
    ip_str = socket.inet_ntoa(ip_bytes[-4:])
    print(f"\n--- Axon Endpoint ---")
    print(f"IP: {ip_str}:{neuron.axon_info.port}")
    print(f"Version: {neuron.axon_info.version}")

# Last activity
current_block = sub.block
blocks_since_update = current_block - neuron.last_update
minutes_since = blocks_since_update * 12 / 60
print(f"\n--- Activity ---")
print(f"Last weight update: block {neuron.last_update} ({blocks_since_update} blocks / ~{minutes_since:.0f} min ago)")

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

const provider = new WsProvider('wss://api-bittensor-mainnet.n.dwellir.com/YOUR_API_KEY');
const api = await ApiPromise.create({ provider });

// Fetch neuron info for UID 0 in subnet 1
const neuronInfo = await api.rpc.neuronInfo.getNeuron(1, 0);
console.log('Raw data size:', neuronInfo.toHex().length, 'bytes');

// With Bittensor types registered:
// console.log('Hotkey:', neuronInfo.hotkey.toHuman());
// console.log('Active:', neuronInfo.active.toString());
// console.log('Emission:', neuronInfo.emission.toString());
// console.log('Validator permit:', neuronInfo.validator_permit.toString());

await api.disconnect();

import requests

url = 'https://api-bittensor-mainnet.n.dwellir.com/YOUR_API_KEY'

# Query neuron state at multiple past blocks to track performance
netuid = 1
uid = 42
block_hashes = ['0xabc...', '0xdef...', '0x123...']  # Past block hashes

for i, block_hash in enumerate(block_hashes):
    payload = {
        'jsonrpc': '2.0',
        'method': 'neuronInfo_getNeuron',
        'params': [netuid, uid, block_hash],
        'id': i + 1
    }
    response = requests.post(url, json=payload)
    result = response.json()
    if result.get('result'):
        print(f"Block {block_hash[:10]}...: {len(result['result']) // 2} bytes")
    # Decode each snapshot to track score changes over time