Skip to content
TAO$188.31
BTC0.002929
MCap$2.21B
Vol$86.07M

API reference / Accounts

Activity feed of an account

GET/api/v2/accounts/{address}/activity
Status
Beta
Auth
API key or OAuth access token
Scope
data:read
Rate limit
plan

Everything that touched the account, one row per thing.

Full description

Everything that touched the account, one row per thing: one per extrinsic it signed or appears in (the slim call, outcome, tx_fee and gas_fee (each only on its own payer's feed) and wrapper label, with the account's own events nested and named), one per block-level event naming it, and, only with source=storage, one per storage change. Each row says how the account took part (role: signer, involved when a call names it, mentioned when only events do) and what it did for it (classification). Filters: source, the extrinsic's call / pallet, the account's event kinds, classification group / class (a row matches when any leg does), a subnet (netuid), heights and times. limit is at most 200 here (default 50). Classification (classification, null when a row is unclassifiable, e.g. a storage row): one leg per event of the account's that classifies, each with class and group (an open vocabulary: clients must not switch exhaustively), the call id, the subnet, the amounts, a swap fee, the direction relative to the account and the counterparty (SS58, with its role). Transfers with module accounts (the pool and basket mechanics behind a stake) and transfers the account is not a party to are not legs; a reverted batch child produces no leg; a proxy call is classified for the real (proxied) account. Direction: stake, unstake, move, swap and basket legs are self for the coldkey; on the hotkey side of someone else's stake none, with the staker as counterparty (role staker); emission in; transfers in / out. Deposits (group deposit: reserve / unreserve between the account's free and reserved balances, self, with balance_from / balance_to, reason and reason_call) are held, not spent. A stake_lock leg (is_flow: false) states a lock, not a movement: never sum it into flows. A root claim is one root_claim leg (with baskets when the per-basket split adds up); its BasketClaimed events are no leg. classification.classes names the row's classes, including the leg-less fee and marker; the account, proxy, pure proxy and multisig lifecycle, commitments and axons are legs without money; and every amount carries its source (event, trace or derived: show a derived amount as approximate). Every counterparty carries its account_kind (what it is from its bytes: custody, protocol or account). limit_order_skipped (a limit order the runtime skipped: order_id, skip_error; the relayer's leg names the owner, role order_owner) and basket_claim_dust_skipped (a basket claim skipped as dust: rows, forfeited_estimate, is_flow: false) move nothing and have no amount. meta.coverage.classification_from_height is where classification starts. Every leg with an amount carries its TAO value (value_tao_rao, value_source event / spot / unpriced, value_usd), and every row the account's free-balance change (free_tao_delta_rao, the transaction fee included; null on storage and income rows); both null on an older answer. Every row states is_self_transfer (a TAO transfer between the account and itself, or, on the merged feed, between two of the accounts asked for: it nets to 0, so never count one side as a flow), is_dust (a dust_lost leg), price_tao_by_netuid (the pool price at the block of each subnet its legs touch, root 1, null unpriced: the operands of the spot values) and tao_usd (the operand of value_usd); the EVM gas fee the account paid is a fee leg (source gas_fee, out, equal to the row's gas_fee); a staker paying TAO into a basket fund is a basket_stake_in leg (out, the TAO paid, units_in the fund units bought, the fund as counterparty, role basket). The row members are null on an older answer. A neuron registration's burn is an out register_neuron leg on its payer's feed (a proxy's real account or a multisig reads it as role involved); the hotkey's and a signing proxy's legs stay none. Also: subnet_lock (the TAO funding a subnet registration: self from free to locked before block 6,573,966, out from it), subnet_lock_refund and dissolve_payout (a dissolved subnet's payout, life_end_height naming the ended life), and every TAO leg's value_source is its amount's own source (event, trace, derived). Further legs: fee_income (a block author's fee share, fee_source: income), the crowdloan group (the payout an acquisition, the rest custody), liquidity positions (lp_add / lp_remove / lp_disabled, position_id, lp_fees: income counted only there, never in the amount or value), stake_burn without an amount, pre-dTAO stakes on their signed origin, a cross-coldkey transfer_stake as transfer_alpha only, and coldkey_swap legs (swap_cost on the old key's). Newest first (order=desc, the default) or oldest first (asc); with no range, the newest rows over all history (no hidden window). from_height / to_height are inclusive heights, from_time / to_time a half-open time window. Cursor paging only, no total (/activity/counts has exact counts); a cursor page costs what the first does (keyset, never an offset). A request reads at most 20,000 of the account's index entries and the whole call is time-boxed (0.9 s), so a page can be very short (e.g. 5 rows of 100) or empty with a non-null next_cursor (meta.page.scan_limited, meta.page.scanned_through_height): keep paging until next_cursor is null. A page bounded below the head (by to_height / to_time, or a cursor page) is cached as settled, unless it reaches, or continues into, blocks below meta.coverage.from_height that are still being indexed, or holds an own unstake leg outside meta.coverage.dust_sweep_from_height .. dust_sweep_to_height (its dust_sweep is not known yet: it can still appear). Accounts are SS58 (wrapped.real, every counterparty.address); args are named fields as the data source renders them (accounts in them already SS58), versioned by meta.data_version's args/... part. Errors are application/problem+json: INVALID_ADDRESS, INVALID_SOURCE, INVALID_CALL, INVALID_PALLET, INVALID_EVENT, UNKNOWN_CALL, UNKNOWN_EVENT, INVALID_GROUP, INVALID_CLASS, INVALID_HEIGHT, INVALID_TIME, INVALID_RANGE, INVALID_ORDER, INVALID_LIMIT, INVALID_CURSOR, INVALID_NETUID, NOT_READY (503, source=storage before its history is complete), CURSOR_STUCK (502, the page's next_cursor would not advance past cursor: never expected; retrying the same cursor will not help, report it), UNKNOWN_PARAMETER, SOURCE_TIMEOUT (503), SOURCE_NOT_READY (503).

Beta: this route may change with one release's notice in the v2 changelog; additive changes need none (x-stability: beta).

Path parameters

addresspath, required· string

The account (any account: coldkey or hotkey): SS58, or 0x + 64 hex.

Query parameters

sourcequery· array of string

Which rows: signed (extrinsics the account signed), involved (extrinsics a call of which names it in its arguments or origin: a transfer's destination, a stake's hotkey, a proxy's real account), event (extrinsics with events naming it, and block-level events naming it) and storage (changes of storage entries keyed by it). Repeat for several (OR); default signed, involved, event. storage is opt-in and not served yet: while its history does not reach the blocks' floor, any request naming it is a 503 NOT_READY (never a partial feed). income (opt-in; a 400 INVALID_SOURCE while it is not available yet) adds one income row per UTC day and subnet: the shares minted to the account (miner incentive, validator take, owner cut, root take: income at mint, already stake; never a basket flush, pool dividends or root claimable), at the day's last block, merged into the feed by (height, kind, netuid); the current day's row is today so far (income.day_status open): the day is not over, so it grows with the newest credited block. A call, pallet or event filter drops income rows; a class / group filter keeps them only when it names income. meta.income_coverage says where income is final: a page asking for income is cached as settled only when its rows and its bound (to_height, or an asc page with a next_cursor) sit at or below closed_through_height. Anything else is a 400 INVALID_SOURCE.

callquery· array of string

Only extrinsic rows whose own call is this kind, Pallet.call_name; repeat for several (OR, and OR with pallet). 400 INVALID_CALL for a malformed one, UNKNOWN_CALL for one the chain never had.

palletquery· array of string

Only extrinsic rows whose own call is in this pallet; repeat for several. 400 INVALID_PALLET for a malformed name, UNKNOWN_CALL for an unknown one.

eventquery· array of string

Only rows with one of the account's events of this kind, Pallet.EventName; repeat for several (OR). 400 INVALID_EVENT for a malformed one, UNKNOWN_EVENT for one the chain never had.

groupquery· array of string

Only rows with a classification leg in this group (e.g. staking, transfer, validator); repeat for several (OR). The vocabulary is open: an unknown group matches nothing. 400 INVALID_GROUP unless a snake_case word.

classquery· array of string

Only rows with a classification leg of this class (e.g. stake, transfer_tao, weights); repeat for several (OR, and AND with group). The vocabulary is open: an unknown class matches nothing. 400 INVALID_CLASS unless a snake_case word.

from_heightquery· integer · 0 to 2147483647

Only rows at or above this height (inclusive).

to_heightquery· integer · 0 to 2147483647

Only rows at or below this height (inclusive).

from_timequery· string (date-time)

Only rows at or after this time (RFC 3339).

Format: date and time, ISO 8601 in UTC
to_timequery· string (date-time)

Only rows before this time (RFC 3339; exclusive).

Format: date and time, ISO 8601 in UTC
orderquery· enum · one of desc, asc · default desc

desc (newest first, the default) or asc (oldest first).

limitquery· integer · default 50 · 1 to 200

Page size, 1..200 (default 50; this route's cap, above it is a 400 INVALID_LIMIT).

cursorquery· string · up to 200 characters

meta.page.next_cursor of the previous page, passed back unchanged with the same other parameters. It is opaque and bound to them: a cursor used with different parameters, or altered, is a 400 INVALID_CURSOR.

includequery· string

names adds the top-level included.names: every distinct account on the page (accounts in data at any depth, event args included) keyed by its SS58 address, each {identity: {name} | null, label: {text, source, confidence, verified, inferred, as_of} | null}; the on-chain identity and the off-chain label are kept apart, and a label is never a chain fact. A missing key means 'not looked up', null means 'none'. At most 500 accounts (included.names_truncated). Still one call (the data source sideloads them in the same statement); an answer with names is cached as a head answer (names follow the head). Anything else is a 400 INVALID_INCLUDE.

netuidquery· integer · 0 to 65535

Only rows touching this subnet: the extrinsic's subnet, an event's netuid key, a storage key's netuid. It scans the account's rows within the per-request budget, so a page can be short or empty with a non-null next_cursor (meta.page.scan_limited): keep paging until next_cursor is null. 400 INVALID_NETUID for anything but 0..65535.

Response

data is a list of objects with these fields. Amounts are integer strings in their base unit, and null means unknown, never zero (see Units and formats). meta.at names the block the answer was read at.

Rows in order by (height, kind, index). Can be shorter than limit, even empty, with a non-null meta.page.next_cursor (meta.page.scan_limited).

kindstring

extrinsic (one row per extrinsic the account signed or appears in, its own events nested), event (one row per block-level event, phase initialization / finalization, naming the account), storage (one row per storage change of the account's, only with source=storage) or income (one row per UTC day and subnet of the shares minted to the account, only with source=income). New values may be added; show an unknown value as is (or generically).

idstring · unit id

The row's key: the extrinsic id ({height}-{index}), the event id ({height}-{index}), {height}-s{key id} for a storage row, or {height}-i{netuid} for an income row. Stable: a live row and an indexed row with the same id are the same (except an open day's income row, which moves with its day).

Pattern: ^[0-9]+-(s|i)?[0-9]+$
heightinteger · unit block

The block.

timestring (date-time) · can be null

The block's Timestamp.set (RFC 3339 UTC, milliseconds). Null for block 0 only.

Format: date and time, ISO 8601 in UTC
block_hashstring

The row's block hash, 0x + 64 lower-case hex: with height it names the block unambiguously, and a row's id is reorg-stable once meta.at is finalized. Never null.

Format: 32-byte hex: 0x and 64 hex digits
rolestring

How the account takes part, the strongest that applies: signer (it signed the extrinsic), involved (a call of the extrinsic names it in its arguments or origin: a transfer's destination, the hotkey of a stake, the real account of a proxy; also the payer of a neuron registration its events do not name, e.g. a proxy's real account or a multisig, whose row carries the register_neuron leg) or mentioned (only its events name it, e.g. as the hotkey of a stake made inside an EVM call; every block-level row and storage row); recipient on income rows only. New values may be added; show an unknown value as is (or generically).

eventsarray of objects

The account's own events in the row (those that name it), in index order, with their named args. [] on storage rows. At most 50 per row: every event matching the request's event filter is kept (up to 1,000), then events naming the account, then the rest; has_more_events says the list is partial, and GET /api/v2/extrinsics/{id}/events has them all.

3 fields in events (each item)
idstring · unit id

The event's id, {height}-{index}.

Format: block and index, such as 4200000-3
eventobject

The event's kind.

2 fields in event
palletstring

The pallet, as in the runtime metadata (e.g. SubtensorModule).

namestring

The event, as in the runtime metadata (PascalCase, e.g. StakeAdded).

argsobject · can be null

The arguments as named fields, served exactly as the data source renders them (never re-rendered here). Names: the block's runtime metadata names each field (snake_case); unnamed tuple fields take their names from a reviewed list of override names (each entry traced to the subtensor source), else the snake_case of the field's type name (_2, _3 when repeated), else arg0, arg1. A field typed NetUidStorageIndex is always netuid_index (= mechanism × 4096 + netuid), never a netuid. Values: accounts (AccountId32 by metadata type) are SS58; amounts are decimal strings in their base unit; enums are {__kind, value}; hashes and bytes are 0x hex; a nested call (batch, proxy, sudo) is {pallet, name, args}. The naming rule and the override names are versioned in meta.data_version (args/<rule>.<overrides>), so a renamed field is a new version. Free-form: the members depend on the kind and the runtime, so this schema does not list them. Null only when the source stored no arguments.

events_totalinteger · unit count · can be null

The row's events before the 50-event cap (for the signer, the extrinsic's events; otherwise the events naming the account). 0 on income and storage rows. Absent until the source states it.

has_more_eventsboolean · can be null

True when events is partial (the cap left some out): never read it as a count. Absent until the source states it.

classificationobject · can be null

What the row did for the account (legs with class, amounts, direction and counterparty). Null when the row is unclassifiable: every storage row, and any row below meta.coverage.classification_from_height. An income row's is the class income alone, without legs.

3 fields in classification
classesarray of string

The row's event classes for the account, sorted and distinct: the legs' classes plus the classes without legs (fee, marker). So legs: [] with classes: ["fee"] means the row moved nothing a leg shows (the fee itself is the row's tx_fee / gas_fee). Open vocabulary: new values can appear without a version bump; clients must not switch exhaustively on it and must show an unknown value as it is.

groupsarray of string

The distinct groups of classes, sorted (so fee and system appear for a fee or a marker without a leg). A row matches group= (or class=) when any leg does. Open vocabulary: new values can appear without a version bump; clients must not switch exhaustively on it and must show an unknown value as it is.

legsarray of objects

One leg per event of the account's in the row that classifies, in event order. Rules: a leg comes from the account's own events, so a batch gives one leg per child that emitted events and a reverted batch child produces no leg (it emitted none); a TAO transfer to or from a module account (modl...: the pool and basket mechanics behind a stake, whose own leg carries the amount) is not a leg, nor is a transfer the account is not a party to, nor a coldkey swap's own balance transfer (the swap's leg carries it). A proxy call is classified for the real (proxied) account: the feed of the account a proxy acted for shows the inner call's legs (role involved). An extrinsic with no classified event is one other leg carrying its call; a block-level row is one emission (a Balances.Deposit), stake_lock (a StakeLocked, mostly block-level) or system_event leg per event. A deposit leg (reserve / unreserve) appears only on the holder's feed, a dust_lost leg only on the reaped account's. A root claim is one root_claim leg (from RootClaimed), so summing amounts counts the claim once: its BasketClaimed events are no leg (the class marker is in classes). fee and marker events have no leg; an other leg appears only when no event of the account's has a class; the account, proxy, pure proxy and multisig lifecycle legs appear on both parties' feeds (each with the other as counterparty).

44 fields in legs (each item)
classstring

What this leg is, a snake_case string. Known classes by group: transfer: transfer_tao, transfer_alpha, coldkey_swap, dust_lost; staking: stake, unstake, move_stake, swap_stake, basket_deposit, basket_stake_in, root_claim, basket_rebalance, burn_alpha, recycle_alpha, stake_burn, auto_stake, stake_lock, limit_order_skipped, basket_claim_dust_skipped, lp_add, lp_remove, lp_disabled; crowdloan: crowdloan_contribute, crowdloan_create, crowdloan_withdraw, crowdloan_payout, crowdloan_refund, crowdloan_dissolve; deposit: reserve, unreserve, repatriate_reserve, storage_deposit; registration: register_neuron, register_network, dissolve_network, subnet_lock, subnet_lock_refund, dissolve_payout; validator: weights, children, take, commitment, serve_axon; identity: identity; evm: evm; account: account_created, account_reaped, proxy_added, proxy_removed, proxy_announced, real_pays_fee, pure_created, pure_killed, multisig_created, multisig_approval, multisig_executed, multisig_cancelled; fee: fee, fee_income; system: emission, system_event, marker; other: other. other is an extrinsic whose events classify nothing for the account (its call says what it was); system_event a block-level event other than an emission deposit; marker a bookkeeping event that moves no money (a BasketClaimed: the claim's money is its root_claim leg). reserve / unreserve move TAO between the account's free and reserved balances (a deposit is held, not spent: the TAO stays the account's); repatriate_reserve moves reserved TAO to another account; storage_deposit is a contract's storage deposit; dust_lost is TAO lost when an account was reaped below the existential deposit; stake_lock is a state (alpha locked in place), not a movement (is_flow: false); root_claim is a root dividend claim (basket_claim on an older data version's answer). limit_order_skipped is a limit order the runtime skipped (order_id, skip_error) and basket_claim_dust_skipped a basket claim skipped as dust (rows, forfeited_estimate, is_flow: false): both move nothing (no amount). The account group's legs (account_created / account_reaped, the proxy, pure proxy and multisig lifecycle) and commitment / serve_axon move no money (no amount). marker is a class without legs (named in classification.classes only: a marker moves nothing), so a leg is never marker. fee names the row's fees in classification.classes: the transaction fee (tx_fee) stays leg-less, while the EVM gas fee the account paid is also a fee leg (source gas_fee, group fee, out, its amount the row's gas_fee); a row with a gas_fee has exactly one (a zero fee too). basket_stake_in is a staker paying TAO into a basket fund, with no netuid: on the staker's feed out, the TAO paid as amount.tao_rao, the fund units bought as units_in, the fund as counterparty (role basket); on the fund's own feed none, the staker as counterparty (role staker), no units_in. Units of a fund, never income. Group registration: subnet_lock is the TAO funding a subnet registration, on the payer's feed: before block 6,573,966 self from free to locked (still the owner's, refundable at dissolution), from it out (spent); its counterparty, when named, is the subnet or the registration escrow (then without a netuid), and it sits on the registration row, a block-level row at settlement (runtimes 432..470) or the transfer to the escrow (472 on). subnet_lock_refund gives a lock back: self from locked to free for a legacy owner at dissolution, in for an escrow refund. dissolve_payout is a holder's TAO paid out of a dissolved subnet (in): its netuid, generation and life_end_height name the life that ENDED. fee_income (group fee, in, on a block author's feed only) is the author's share of a fee (fee_source): income. Group crowdloan: crowdloan_contribute (out), crowdloan_withdraw (in), crowdloan_create (the creation deposit, usually out), crowdloan_payout (the finalized fund paid to the creator, usually in), crowdloan_refund and crowdloan_dissolve (usually in), the fund account as counterparty (role crowdloan: a custody account, its crowdloan id; or the creator); the payout is an acquisition of TAO, every other crowdloan leg custody (the TAO stays the contributor's claim on the fund). Liquidity positions (group staking): lp_add / lp_remove (self on the provider's feed, balance_to / balance_from lp_position, position_id; TAO and alpha, valued spot: the TAO plus the alpha at the pool's price; lp_fees the fees a change collected, income counted only there) and lp_disabled (self, balance_from lp_position to balance_to free, TAO only, no subnet: a position returned when the subnet disabled user liquidity); the hotkey's feed shows the provider's lp_add / lp_remove as none with the same amount (role liquidity_provider). stake_burn (an add_stake_burn) moves nothing itself (none, no amount, is_flow false): the TAO paid is the stake leg's and the alpha burned the burn_alpha leg's. coldkey_swap moves the old key's balance: out on the old key (with swap_cost), in on the new one; a scheduled swap's rows are block-level events, its Withdraw / Deposit system_event legs without an amount. A pre-dTAO stake (to block 4,920,349) is the call's Signed origin's (self, no netuid; e.g. a multisig), the signatory's leg none (role staker); a transfer_stake between two coldkeys is one transfer_alpha leg on each side (no stake / unstake legs; to the same coldkey they stay, both self). register_network can sit on a registration-queue row (NetworkRegistrationQueued, v432+) as a none leg without a netuid. Open vocabulary: new values can appear without a version bump; clients must not switch exhaustively on it and must show an unknown value as it is.

groupstring

The class's group, a snake_case string: transfer, staking, crowdloan, deposit, registration, validator, identity, evm, account, fee, system, other (the classes of each are listed on class). Open vocabulary: new values can appear without a version bump; clients must not switch exhaustively on it and must show an unknown value as it is.

directionenum

Which way value moved, relative to the account the feed is for: in, out, self or none. Transfers (TAO, alpha, a coldkey swap) are in / out (self when the account is both sides). Stake, unstake, moving or swapping stake and basket deposits / claims are self for the coldkey that owns the stake (the value stays the account's, in another form); on the hotkey side of someone else's stake they are none, with the staker as counterparty (role staker). An emission deposit is in; burned / recycled alpha out for its coldkey; a stake burn out for the account that signed it (none for anyone else); an auto-stake in for its owner. A root claim is self for the claiming coldkey (or the signer). reserve / unreserve are self for the holder (free and reserved are both the account's); repatriate_reserve and storage_deposit out for the paying side and in for the receiving one; dust_lost out for the reaped account; stake_lock self for the coldkey and none on the hotkey (staker as counterparty). A basket rebalance, weights, children, take, registration, identity, EVM, other and system_event are none, except a register_neuron leg on the feed of the registration's payer (the call's own signed origin: a proxy's real account, a multisig; on EVM the transfer's sender), which is out with the TAO the registration burned as its amount; the hotkey, a proxy that signed for the payer and a registration that burned nothing (proof of work, root) stay none. subnet_lock is self (free to locked) before block 6,573,966 and out from it, subnet_lock_refund self (locked to free) or in (an escrow refund), dissolve_payout in. fee_income in; crowdloan_contribute out, crowdloan_withdraw in, the other crowdloan classes in, out or self by which side of the fund the account is; lp_add / lp_remove self for the provider and none on the hotkey (role liquidity_provider), lp_disabled self (the position back to free); a pre-dTAO stake is self for the call's signed origin (e.g. a multisig), none for the signer and the hotkey (the origin as counterparty, role staker); a transfer_stake to another coldkey is transfer_alpha out / in only (no unstake / stake legs); a stake_burn is none; a coldkey_swap out on the old key and in on the new. account_created / account_reaped are self for the account; the proxy, pure proxy and multisig legs, commitment, serve_axon, limit_order_skipped and basket_claim_dust_skipped are none (they move no money).

One of: in, out, self, none
call_idstring · unit id · optional

The call that emitted the leg's event (a call id: 9193482-5.1 is the second call inside extrinsic 9193482-5's batch), or the extrinsic id when the event has no call. Absent on block-level rows.

Pattern: ^[0-9]+-[0-9]+(\.[0-9]+)*$
netuidinteger · unit id · can be null

The subnet of the leg (a netuid_index is reduced to its subnet). Always present: null when the event has none.

amountobject · can be null

What the leg moved (or, on a stake_lock leg, locked: is_flow false), each amount with its source. Always present: null when it moved no amount (weights, children, identity, other, the account group, commitment and serve_axon); never 0 for no amount.

swap_feevalue · optional

Only on stake / unstake legs: the pool's swap fee as the leg's own event states it (TAO for a StakeAdded; for a StakeRemoved alpha from runtime 290, TAO in runtimes 257..277). Absent, never null, where the event states no fee (a StakeRemoved before runtime 257). A zero fee is kept ("0"). Not a transaction fee: that is the row's tx_fee.

counterpartyvalue · optional

The other account of the leg and its role. Absent when there is none (weights, emission, other, a stake whose event names no hotkey, reserve / unreserve (the holder's own balances), dust_lost, account_created / account_reaped, commitment, serve_axon, and a root_claim unless the claim went through exactly one basket).

opstring · optional

Only on weights legs: set, commit or reveal. Absent on every other leg. New values may be added; show an unknown value as is (or generically).

takestring · unit ratio · optional

Only on take legs: the new take as a ratio, the chain's u16 / 65535 (decimal string; 11796 is 0.18). Absent when the event does not carry it.

Format: decimal number, as a string
uidinteger · unit id · optional

Only on register_neuron legs: the UID registered.

generationinteger · unit id · can be null · beta

Opaque life id (the life's registration identifier), NOT a block height; use life_start_height for the first block. That subnet's life at the row's block: two lives of one netuid are two positions. Always present: null where the leg names no subnet (netuid null) or the slot has no recorded life (root).

life_start_heightinteger · unit block · can be null

The first block of the life generation names (GET /subnets/generations' start_height): use it, never generation, for heights, ages and dates. Null exactly when generation is null (root without a life, no subnet), or transiently when this API cannot read the lives. Root's generation 0 starts at 0.

is_current_lifeboolean · can be null

Whether generation is the slot's current life (true) or an ended one, re-registered since (false). Null exactly when generation is null, or transiently when this API cannot read the lives. Root's generation 0 is current.

destination_generationinteger · unit id · can be null · beta

Beside destination_netuid only: the destination subnet's life at the row's block (a move), an opaque life id like generation, NOT a block height. Absent without destination_netuid, and where the source states no life for it (root).

destination_netuidinteger · unit id · optional

Only on transfer_alpha, move_stake, swap_stake and basket_rebalance legs: the subnet the alpha went to (netuid is where it came from). Absent when the event does not name one.

dust_sweepobject · can be null

Only on the feed account's own unstake legs (the coldkey's), three states: an object = a dust sweep happened; null = verified, no sweep; absent = unknown: the block is outside the dust sweep derivation's coverage (meta.coverage.dust_sweep_from_height .. dust_sweep_to_height), not "no sweep"; inside it the member is always stated. This is the one leg member where null and absent differ (every other one is absent, never null). A full unstake removed more alpha than StakeRemoved states; the position ends at 0. alpha_rao is that extra alpha (from the chain's state). If its value is at least 1 rao, the runtime paid it as TAO in a separate transfer from the subnet's pallet account (tao_rao); below 1 rao nothing was paid and tao_rao is "0". Total TAO received for this unstake = amount.tao_rao + dust_sweep.tao_rao.

callvalue · optional

Only on other legs: the extrinsic's own call, which nothing classified for the account.

balance_fromenum · optional

Only on reserve / unreserve legs: the account's balance the TAO left (free for a reserve, reserved for an unreserve). A reserve moves TAO between two balances of the same account: a deposit is held, not spent, and is no outflow. Also free on a self subnet_lock (before block 6,573,966), locked on a self subnet_lock_refund, and lp_position on the provider's lp_remove. Each a move between the same account's balances, no outflow. Absent (never null) on every other leg.

One of: free, reserved, locked, lp_position
balance_toenum · optional

Only on reserve / unreserve / repatriate_reserve legs: the balance the TAO entered (reserved for a reserve, free for an unreserve; on a repatriation the event's status, the receiving account's free or reserved balance). Also locked on a self subnet_lock (the owner's lock, refundable), free on a self subnet_lock_refund, and lp_position on the provider's lp_add. Absent (never null) on every other leg.

One of: free, reserved, locked, lp_position
reasonstring · optional

Only on deposit legs (reserve, unreserve, repatriate_reserve, storage_deposit): why the deposit was taken or released, from the call that did it: multisig_deposit, proxy_deposit, identity_deposit, registration, contract_storage (always on storage_deposit) or other (the call does not decide it; never a guess). Absent (never null) on every other leg. New values may be added; treat unknown values as unavailable.

reason_callstring · optional

Only on deposit legs: the call reason was read from, Pallet.call_name as the runtime names it (e.g. Multisig.as_multi, Proxy.add_proxy). Absent (never null) when the extrinsic has no call, and on every other leg.

Pattern: ^[A-Za-z0-9_]+\.[A-Za-z0-9_]+$
basketsarray of objects · optional

Only on root_claim legs: the claim per basket, from the extrinsic's BasketClaimed events for the coldkey, in event order; present only when they sum exactly to amount.tao_rao. Absent = unknown (no BasketClaimed, or a split that does not add up), never null and never a guess.

is_flowboolean · optional

Only on stake_lock, basket_claim_dust_skipped and stake_burn legs (on stake_burn, whose TAO and alpha are the stake and burn_alpha legs'), always false: the leg states a state (alpha locked on a hotkey; a claim skipped as dust), not a movement. Never sum it into flows (inflows, outflows, net change). Absent (never null) on every other leg, where the leg's amounts are movements.

proxy_typestring · optional

Only on proxy_added / proxy_removed / proxy_announced / pure_created / pure_killed legs: the proxy type as the runtime names it (e.g. Any, Staking). Absent (never null) when the event does not state it, and on every other leg. Open vocabulary: new values can appear without a version bump; clients must not switch exhaustively on it and must show an unknown value as it is.

delayinteger · unit blocks · optional

Only on proxy_added / proxy_removed legs: the proxy's announcement delay, in blocks. Absent (never null) when the event does not state it, and on every other leg.

call_hashstring · optional

Only on multisig_* and proxy_announced legs: the hash of the call approved, executed, cancelled or announced, 0x + 64 lower-case hex. Absent (never null) on every other leg.

Format: 32-byte hex: 0x and 64 hex digits
pays_feeboolean · optional

Only on real_pays_fee legs: whether the real account now pays its proxy's transaction fees. Absent (never null) on every other leg.

successboolean · optional

Only on multisig_executed legs: whether the multisig's inner call succeeded (false: the multisig executed, its call failed). Absent (never null) on every other leg.

reveal_roundstring · unit id · optional

Only on a timelocked commitment leg: the drand round it reveals at (decimal string). Absent (never null) on a plain commitment and on every other leg.

Format: whole number, as a string
order_idstring · optional

Only on limit_order_skipped legs: the skipped order's id, 0x + 64 lower-case hex. The owner's feed shows the leg without a counterparty; the relayer's (the extrinsic's signer) names the owner as counterparty (role order_owner). When the extrinsic carried more than one order the owner is not attributed: only the relayer's feed shows the skip, without a counterparty. Absent (never null) on every other leg.

Format: 32-byte hex: 0x and 64 hex digits
skip_errorvalue · optional

Only on limit_order_skipped legs: why the runtime skipped the order, the event's DispatchError decoded with the block's runtime. Absent (never null) on every other leg.

rowsinteger · unit count · optional

Only on basket_claim_dust_skipped legs: how many claim rows the runtime skipped as dust. Absent (never null) on every other leg.

forfeited_estimatevalue · optional

Only on basket_claim_dust_skipped legs: the TAO the skipped rows were worth, as the event estimates it, with its source. Not an amount: nothing moved (the leg has no amount and is_flow is false). Absent (never null) on every other leg.

value_tao_raostring · unit rao (÷1e9) · can be null

The leg's value in TAO, rao: the TAO its event states (value_source event), else its alpha at the pool's price at the block (spot; root 1:1). Null when unpriced, and on an older answer. Present only beside an amount.

Format: whole number, as a string
value_sourcestring · can be null

Where value_tao_rao comes from: the leg's own TAO amount, with that amount's own source (value_source = amount.tao_source, so event, trace (e.g. a register_neuron burn) or derived (a burn before block 223,049: approximate); always event on an older data version's answer), spot (alpha x the pool's price at the block: a valuation, not what a swap would pay; on a liquidity position leg moving both, its TAO plus its alpha at that price) or unpriced (no price: both values null). Null on an older answer. Present only beside an amount. New values may be added; show an unknown value as is (or generically).

value_usdstring · unit usd · 6 decimals · can be null

value_tao_rao in USD at TAO/USD at the block's time. Null when value_tao_rao is or no TAO/USD price exists, and on an older answer.

Format: decimal number, as a string
sourcestring · optional

Only on a fee leg: gas_fee, the leg is the row's EVM gas fee (TAO withdrawn minus refunded on the payer, out, its amount exactly gas_fee.amount_rao; call_id the row's id). Exactly one on every row with a non-null gas_fee, a zero amount included; none on any other row. Absent (never null) on every other leg. The Substrate transaction fee is no leg (the row's tx_fee). New values may be added; show an unknown value as is (or generically).

units_invalue · optional

Only on basket_stake_in legs: the fund units the stake bought (the event's shares). The TAO paid is the leg's amount.tao_rao (direction out). Units of a fund, never income and never TAO. Absent (never null) on every other leg.

life_end_heightinteger · unit block · optional

Only on dissolve_payout and subnet_lock_refund legs: the block the paying subnet life ended (dissolved). With netuid and generation (that life's start) it names the ENDED life, not the slot's current one. Absent (never null) on every other leg.

fee_sourcestring · optional

Only on fee_income legs (a block author's): which fee the author's share came from: tx_fee (a transaction fee), swap_fee (a pool swap fee; the pool as counterparty, role pool) or gas_fee (an EVM gas fee). Income to the author; the payer's own fee is unchanged (its row's tx_fee / gas_fee). Absent (never null) on every other leg. New values may be added; show an unknown value as is (or generically).

position_idstring · unit id · optional

Only on lp_add / lp_remove legs (the provider's and the hotkey's): the liquidity position's id (decimal string). Absent (never null) on lp_disabled and every other leg.

Format: whole number, as a string
lp_feesvalue · optional

Only on lp_add / lp_remove legs that collected fees (a modification of a position collects them; an add can carry them): the fees, TAO and alpha, each with its source. Income, counted only here: never inside the leg's amount or its value (value_tao_rao), so a flow sum and an income sum never count them twice. Absent (never null) on every other leg.

swap_costvalue · optional

Only on the old key's coldkey_swap leg (out): what the swap cost it (amount_rao in asset tao, with its source). Not part of the balance moved (amount): the old key's free balance fell by both. Absent (never null) on every other leg.

free_tao_delta_raostring · unit rao (÷1e9) · can be null

The account's free-balance change in the row, rao, signed, from its Balances events (transfers in and out, the Withdraw of the transaction fee included, Deposit, Burned, DustLost, Reserved / Unreserved, a repatriation to its free balance); 0 when none. Null on storage and income rows, and on an older answer.

Format: whole number, as a string · can be negative
is_self_transferboolean · can be null

The row is a TAO transfer with both sides the account (on the merged feed: both sides among the accounts asked for, one row per side). Such a transfer nets to 0: in free_tao_delta_rao when both legs are on one row (the change is then what else moved, e.g. the fee), and across the rows of a merged page (sum them; never count one side as a flow). On a row with no other Balances movement of the account, free_tao_delta_rao is minus (tx_fee.amount_rao + tx_fee.tip_rao), the chain's actual fee, when the account paid the fee in TAO, else 0. Null on an older answer.

is_dustboolean · can be null

The row has a dust_lost leg (Balances.DustLost of the account: a balance swept below the existential deposit). Null on an older answer.

price_tao_by_netuidobject · unit tao_per_alpha · can be null

{netuid: TAO per alpha}, the pool price at the row's block (root 1; null where the subnet has no price), keyed exactly by the netuid and destination_netuid of every leg with an amount (legs that move nothing, e.g. weights, children, take, add none; an income row: its own subnet), a leg moving TAO alone included (e.g. a subnet lock or a payout; an escrow-era lock names no subnet): the operands of the legs' spot values. {} when no such leg names a subnet. Null on an older answer.

Format: decimal number, as a string
tao_usdstring · unit usd_per_tao · can be null

TAO/USD at the row's block time, the operand of every leg's value_usd. Null when no price exists (every value_usd is then null too), and on an older answer.

Format: decimal number, as a string
generation_by_netuidobject · can be null · beta

{netuid: generation}: the life each subnet a leg names (netuid or destination_netuid) had at the row's block (null: a slot without a recorded life, root); {} when no leg names a subnet. Two lives of one netuid are two positions. It is the legs' own generation (a dissolve_payout or subnet_lock_refund names the ENDED life, so one block's row can name another life on another feed). Null on a row read before the source served it.

incomevalue · optional

Only on income rows (source=income; absent on the others): the day's income on the subnet. Income at mint only (miner incentive, validator take, owner cut, root take): never a basket flush, pool dividends or root claimable.

netuidsarray of values · optional

Every subnet the extrinsic's call tree names, ascending (the netuid filter's own index, so the filter and the row agree; empty when none does; absent on an older answer). Only on extrinsic rows (absent on the others).

netuidinteger · unit id · can be null

The one subnet the call tree names; null when it names none or several (see netuids). Only on extrinsic rows (absent on the others).

mechanism_idinteger · unit id · can be null

The calls' mechanism id when they name exactly one (weights / commit / reveal on a mechanism); null otherwise. Only on extrinsic rows (absent on the others).

callvalue · optional

The extrinsic's own (top-level) call. Only on extrinsic rows (absent on the others).

successboolean · optional

Whether the extrinsic succeeded. Only on extrinsic rows (absent on the others).

tx_feeobject · can be null

The extrinsic's Substrate transaction fee, only on its payer's feed: present when this account is the fee's payer, null on everyone else's feed (the signer's too, when someone else paid, e.g. a proxy whose real account pays), for inherents and for Ethereum.transact. So summing tx_fee over one account's feed counts each fee it paid exactly once. Only on extrinsic rows (absent on the others).

9 fields in tx_fee
payerstring

The account that paid, SS58 (the source's 0x hex, rendered): the account the chain's fee event names (TransactionFeePaid.who). Not always the signer: a proxy setup can charge the real account, and for weights / commitments / serve_axon it is the signing hotkey's owning coldkey (SubtensorModule.Owner), with a fee of 0. Group fees by payer, never by signer.

Format: SS58 address
assetstring

What the fee was paid in: tao, or alpha of netuid (TransactionFeePaidWithAlpha: the fee extension sold the payer's alpha to pay it). It names amount_rao's denomination. New values may be added; show an unknown value as is (or generically).

netuidinteger · unit id · can be null

When asset is alpha: the subnet whose alpha paid. Null for tao.

amount_raostring · unit rao (÷1e9)

The fee in the paid asset's base unit (decimal string), the tip excluded: rao when asset is tao, alpha rao of netuid when asset is alpha (a mixed-denomination field: x-unit keeps rao as the 1e9 scale and asset names the denomination; never add an alpha amount to TAO). In TAO: TransactionFeePaid.actualFee - tip; in alpha: TransactionFeePaidWithAlpha.alphaFee. The whole fee in TAO terms is amount_rao + tip_rao for tao, tao_equivalent_rao + tip_rao for alpha.

Format: whole number, as a string · on chain: u64
tip_raostring · unit rao (÷1e9)

The tip, rao (TAO, decimal string): TransactionFeePaid.tip, paid on top of amount_rao.

Format: whole number, as a string · on chain: u64
tao_equivalent_raostring · unit rao (÷1e9) · can be null

When asset is alpha: the TAO the alpha sale realized to pay the fee, rao (TransactionFeePaidWithAlpha.taoAmount); always present on an alpha fee. Null for tao. The fee's cost in TAO terms is tao_equivalent_rao + tip_rao, but no TAO left the payer for it: never add it to amount_rao (alpha) or sum it with stated TAO movements (transfers, balances) as if TAO had moved.

Format: whole number, as a string · on chain: u64
amount_usdstring · unit usd · 6 decimals · can be null

The fee in USD (6 decimals): the TAO it cost (amount_rao for tao; for alpha its tao_equivalent_rao) at the TAO/USD price of the block's own minute. Derived (usd_source), never stated by the chain. Null when no price exists for that minute: unknown, never 0.

Format: decimal number, as a string
tip_usdstring · unit usd · 6 decimals · can be null

tip_rao in USD at the same price (6 decimals). Null when no price exists (unknown, never 0).

Format: decimal number, as a string
usd_sourcestring

Where the USD amounts come from (an opaque identifier): derived (the chain's fee amount times the market TAO/USD of the block's minute), never a chain statement. Show them as approximate; sum the _rao amounts, not these, for exact totals. New values may be added; show an unknown value as is (or generically).

gas_feeobject · can be null

The extrinsic's EVM gas (always TAO), only on its payer's feed (the account mapped from the H160 sender), null elsewhere and on non-EVM extrinsics. A signed EVM.call can show its tx_fee on the signer's feed and its gas_fee on the mapped account's: each fee on exactly one feed. Only on extrinsic rows (absent on the others).

3 fields in gas_fee
payerstring

The account that paid the gas, SS58 (the source's 0x hex, rendered): the account mapped from from. Not necessarily the tx_fee payer (a signed EVM.call charges its signer the Substrate fee and the mapped account the gas). Group fees by payer.

Format: SS58 address
fromstring

The H160 sender, 0x + 40 lower-case hex, as the EVM transaction or call names it (not rendered; payer is the account it maps to).

Format: EVM address: 0x and 40 hex digits
amount_raostring · unit rao (÷1e9)

The gas paid, always TAO, rao (decimal string): the Balances withdraw minus the refund on the payer, i.e. the gas at the base fee only, never gas_used x effective_gas_price (a legacy transaction priced above the base fee did not pay that price).

Format: whole number, as a string · on chain: u64
wrappedobject · can be null

For a wrapper call (Utility.batch / batch_all / force_batch / as_derivative / dispatch_as / dispatch_as_fallible / with_weight / if_else, Proxy.proxy / proxy_announced, every Sudo call, Multisig.as_multi / as_multi_threshold_1): what it dispatched, counted by kind, and the proxied account. Null for every other call. Only on extrinsic rows (absent on the others).

3 fields in wrapped
countinteger · unit count

Direct inner calls (one level below the extrinsic's call).

callsarray of objects

The direct inner calls by kind, in the order each kind first appears.

3 fields in calls (each item)
palletstring

The inner call's pallet.

namestring

The inner call's name.

countinteger · unit count

How many direct inner calls of this kind.

realstring · can be null

For Proxy.proxy / proxy_announced: the proxied (real) account the call acted for, SS58 (the source's 32-byte hex, rendered). Null for every other wrapper, and when the proxy named the real account by another MultiAddress form than an account id (an index, a 20-byte or raw address).

Format: SS58 address
evm_tx_hashstring · can be null

An Ethereum.transact extrinsic's EVM transaction hash, 0x + 64 lower-case hex; null on every other extrinsic. Only on extrinsic rows (absent on the others).

Format: 32-byte hex: 0x and 64 hex digits
multisig_operationobject · can be null

The multisig operation this row's Multisig.* call acted on (an extrinsic row: its top-level call), with its role. Null on every other row, and on an answer read before the source served it.

4 fields in multisig_operation
accountobject

The multisig account (derived from the call's signatories).

2 fields in account
ss58string

The account, SS58 (prefix 42).

Format: SS58 address
hexstring

The same 32-byte account id, 0x + 64 lower-case hex (the public key).

Format: 32-byte hex: 0x and 64 hex digits
timepointobject · can be null

The operation's timepoint (the extrinsic that opened it). Null only on a failed_attempt that named none (or none that can name an extrinsic).

2 fields in timepoint
heightinteger · unit block

Its block.

indexinteger · unit id

Its extrinsic index in the block.

call_hashstring · can be null

The operation's call hash, 0x + 64 lower-case hex. Null only on a failed_attempt whose args carry none.

Format: 32-byte hex: 0x and 64 hex digits
rolestring

What this call did: created (NewMultisig), approved (MultisigApproval), executed (MultisigExecuted: the final approval dispatched the call; an as_multi_threshold_1 too), cancelled (MultisigCancelled) or failed_attempt (no Multisig event: the call failed or was rolled back; the account derived from its signatories, timepoint and call hash from its own args where it carries them). A closed set. New values may be added; show an unknown value as is (or generically).

extrinsic_idstring · unit id · can be null

Only on storage rows: the extrinsic that made the change; null for a block hook.

Format: block and index, such as 4200000-3
itemobject · can be null

Only on storage rows: the storage item, {pallet, name}; null when unknown.

2 fields in item
palletstring

The pallet, as in the runtime metadata (e.g. SubtensorModule).

namestring

The storage item, as in the runtime metadata (e.g. StakingHotkeys).

keystring · can be null

Only on storage rows: the changed storage key, 0x + lower-case hex.

Format: hex: 0x and hex digits

Response headers

10 headers: ETag, Cache-Control, CDN-Cache-Control, X-BTAI-Stale, X-BTAI-Stale-As-Of, RateLimit-Policy, RateLimit, X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset
ETag

Strong validator of this answer. Send it back as If-None-Match: an unchanged answer is a 304 Not Modified without a body. A settled answer's validator leaves the chain head out, so it stays valid as the head moves.

Cache-Control

One of three classes: settled public, max-age=3600, stale-while-revalidate=86400 (pinned to a block that cannot move), slow public, max-age=300, stale-while-revalidate=600 (state that moves in minutes or days) or tip public, max-age=6, stale-while-revalidate=12 (follows the chain head); the label routes are cached until the next nightly copy (public, max-age=<seconds>, stale-while-revalidate=60). Never immutable. no-store on an earlier answer served because the data source failed (X-BTAI-Stale).

CDN-Cache-Control

The same class for shared caches (RFC 9213; browsers ignore it): settled 24 h, slow 300 s, tip 6 s, each with stale-while-revalidate and stale-if-error; no-store with X-BTAI-Stale.

X-BTAI-Stale

Present only when the data source failed to answer (it timed out or was unavailable) and an earlier answer to the same request is served instead of a 503 (stale if error, RFC 5861). Then if-error, with X-BTAI-Stale-As-Of, Age (its seconds since then) and Warning: 110 - "Response is Stale", and Cache-Control: no-store: the answer is never kept as fresh, and a later request reads again. Prices and quotes are never served this way.

X-BTAI-Stale-As-Of

With X-BTAI-Stale: when the earlier answer served was produced, an RFC 3339 UTC time (2026-10-21T12:00:00Z).

RateLimit-Policy

The tier's request quota of the current window (IETF draft), e.g. "tier";q=600.

RateLimit

Requests left in the current window and the seconds until it resets (IETF draft), e.g. "tier";r=597;t=42.

X-RateLimit-Limit

The tier's request quota of the current window.

X-RateLimit-Remaining

Requests left in the current window.

X-RateLimit-Reset

When the current window resets, Unix seconds.

Status codes

200 · 304 · 400 · 401 · 402 · 403 · 404 · 429 · 500 · 502 · 503

304 Not Modified: the If-None-Match validator still matches; no body.

Error codes

The codes this endpoint can return. Each links to what it means and what to do.

From the API's published specification, version 1.165.0.