Activity feed of several accounts, merged
https://api.bittensor.ai/api/v2/accounts/activity- Status
- Beta
- Auth
- API key or OAuth access token
- Scope
data:read- Rate limit
plan
Several accounts' activity as one feed.
Full description
Several accounts' activity as one feed: up to 60 accounts on this GET form (the request line's limit) or 500 on the POST /batch form, each account's GET /accounts/{address}/activity rows (the same rows, filters and rules: each row as that account's own feed serves it, role, events, classification and fees included) plus address, the account whose feed the row came from ({ss58, hex}), merged in order by (height, kind (event, extrinsic, storage, income), index (an income row's: its netuid), address): a row that touches two of the accounts appears once per account. Keyset-paged by meta.page.next_cursor (no total); a page can be short, even empty, with a non-null next_cursor (a busy account's read holds the page back to where every account is complete): keep paging until it is null. meta.addresses lists the accounts merged (each once). limit is at most 100 here (default 50). More accounts than the form takes is a 400 BATCH_TOO_LARGE (the cap in its detail). Cost: the data source reads every account's feed for each page: a cold first page of 250 accounts takes ~10 s, each later page ~1.5 s, and source=income computes every account's income rows first (slower still): page with the cursor rather than asking for more accounts at once. A GET page bounded below the head (to_height / to_time, or a cursor page) is cached as settled on the single feed's rules. 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). Errors are application/problem+json: ADDRESSES_REQUIRED, BATCH_TOO_LARGE, INVALID_ADDRESS (each invalid entry named by its index), 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_INCLUDE, 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).
Query parameters
- addressquery· string
A comma list of 1..60 accounts (any account: coldkey or hotkey), SS58 or 0x + 64 hex, merged into one feed (a duplicate is merged once and The edge caps the request line at 4,094 bytes, so more than 60 is a 400
BATCH_TOO_LARGE(the caps in itsdetail): the POST/batchform takes the same parameters as a JSON body, up to 500 accounts. Omitted or empty: a 400ADDRESSES_REQUIRED; an invalid entry a 400INVALID_ADDRESSnaming its index.- 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) andstorage(changes of storage entries keyed by it). Repeat for several (OR); defaultsigned,involved,event.storageis opt-in and not served yet: while its history does not reach the blocks' floor, any request naming it is a 503NOT_READY(never a partial feed).income(opt-in; a 400INVALID_SOURCEwhile it is not available yet) adds oneincomerow 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_statusopen): the day is not over, so it grows with the newest credited block. Acall,palletoreventfilter drops income rows; aclass/groupfilter keeps them only when it namesincome.meta.income_coveragesays where income is final: a page asking forincomeis cached as settled only when its rows and its bound (to_height, or anascpage with anext_cursor) sit at or belowclosed_through_height. Anything else is a 400INVALID_SOURCE.- callquery· array of string
As
/accounts/{address}/activity'scall(repeat for several).- palletquery· array of string
As
/accounts/{address}/activity'spallet(repeat for several).- eventquery· array of string
As
/accounts/{address}/activity'sevent(repeat for several).- groupquery· array of string
As
/accounts/{address}/activity'sgroup(repeat for several; an open vocabulary).- classquery· array of string
As
/accounts/{address}/activity'sclass(repeat for several; an open vocabulary).- 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) orasc(oldest first).- limitquery· integer · default 50 · 1 to 100
Page size, 1..100 (default 50; this route's cap, above it is a 400
INVALID_LIMIT).- cursorquery· string · up to 200 characters
meta.page.next_cursorof 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 400INVALID_CURSOR.- includequery· string
namesadds the top-levelincluded.names: every distinct account on the page (accounts indataat 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 400INVALID_INCLUDE.
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 (event, extrinsic, storage, income), index (an income row's: its netuid), address). Can be shorter than limit, even empty, with a non-null meta.page.next_cursor.
- 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 withsource=storage) orincome(one row per UTC day and subnet of the shares minted to the account, only withsource=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
heightit names the block unambiguously, and a row'sidis reorg-stable oncemeta.atis 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 theregister_neuronleg) ormentioned(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);recipienton 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'seventfilter is kept (up to 1,000), then events naming the account, then the rest;has_more_eventssays the list is partial, andGET /api/v2/extrinsics/{id}/eventshas 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,_3when repeated), elsearg0,arg1. A field typedNetUidStorageIndexis alwaysnetuid_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 inmeta.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
eventsis 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 classincomealone, 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). Solegs: []withclasses: ["fee"]means the row moved nothing a leg shows (the fee itself is the row'stx_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 (sofeeandsystemappear for a fee or a marker without a leg). A row matchesgroup=(orclass=) 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 (roleinvolved). An extrinsic with no classified event is oneotherleg carrying itscall; a block-level row is oneemission(a Balances.Deposit),stake_lock(a StakeLocked, mostly block-level) orsystem_eventleg per event. A deposit leg (reserve/unreserve) appears only on the holder's feed, adust_lostleg only on the reaped account's. A root claim is oneroot_claimleg (from RootClaimed), so summing amounts counts the claim once: its BasketClaimed events are no leg (the classmarkeris inclasses).feeandmarkerevents have no leg; anotherleg 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 ascounterparty).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.otheris an extrinsic whose events classify nothing for the account (itscallsays what it was);system_eventa block-level event other than an emission deposit;markera bookkeeping event that moves no money (a BasketClaimed: the claim's money is itsroot_claimleg).reserve/unreservemove TAO between the account's free and reserved balances (a deposit is held, not spent: the TAO stays the account's);repatriate_reservemoves reserved TAO to another account;storage_depositis a contract's storage deposit;dust_lostis TAO lost when an account was reaped below the existential deposit;stake_lockis a state (alpha locked in place), not a movement (is_flow: false);root_claimis a root dividend claim (basket_claimon an older data version's answer).limit_order_skippedis a limit order the runtime skipped (order_id,skip_error) andbasket_claim_dust_skippeda basket claim skipped as dust (rows,forfeited_estimate,is_flow: false): both move nothing (noamount). Theaccountgroup's legs (account_created/account_reaped, the proxy, pure proxy and multisig lifecycle) andcommitment/serve_axonmove no money (noamount).markeris a class without legs (named inclassification.classesonly: a marker moves nothing), so a leg is nevermarker.feenames the row's fees inclassification.classes: the transaction fee (tx_fee) stays leg-less, while the EVM gas fee the account paid is also afeeleg (sourcegas_fee, groupfee,out, its amount the row'sgas_fee); a row with agas_feehas exactly one (a zero fee too).basket_stake_inis a staker paying TAO into a basket fund, with nonetuid: on the staker's feedout, the TAO paid asamount.tao_rao, the fund units bought asunits_in, the fund ascounterparty(rolebasket); on the fund's own feednone, the staker ascounterparty(rolestaker), nounits_in. Units of a fund, never income. Groupregistration:subnet_lockis the TAO funding a subnet registration, on the payer's feed: before block 6,573,966selffromfreetolocked(still the owner's, refundable at dissolution), from itout(spent); its counterparty, when named, is thesubnetor the registrationescrow(then without anetuid), 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_refundgives a lock back:selffromlockedtofreefor a legacy owner at dissolution,infor an escrow refund.dissolve_payoutis a holder's TAO paid out of a dissolved subnet (in): itsnetuid,generationandlife_end_heightname the life that ENDED.fee_income(groupfee,in, on a block author's feed only) is the author's share of a fee (fee_source): income. Groupcrowdloan:crowdloan_contribute(out),crowdloan_withdraw(in),crowdloan_create(the creation deposit, usuallyout),crowdloan_payout(the finalized fund paid to the creator, usuallyin),crowdloan_refundandcrowdloan_dissolve(usuallyin), the fund account ascounterparty(rolecrowdloan: acustodyaccount, its crowdloan id; or thecreator); the payout is an acquisition of TAO, every other crowdloan leg custody (the TAO stays the contributor's claim on the fund). Liquidity positions (groupstaking):lp_add/lp_remove(selfon the provider's feed,balance_to/balance_fromlp_position,position_id; TAO and alpha, valuedspot: the TAO plus the alpha at the pool's price;lp_feesthe fees a change collected, income counted only there) andlp_disabled(self,balance_fromlp_positiontobalance_tofree, TAO only, no subnet: a position returned when the subnet disabled user liquidity); the hotkey's feed shows the provider'slp_add/lp_removeasnonewith the same amount (roleliquidity_provider).stake_burn(anadd_stake_burn) moves nothing itself (none, noamount,is_flowfalse): the TAO paid is thestakeleg's and the alpha burned theburn_alphaleg's.coldkey_swapmoves the old key's balance:outon the old key (withswap_cost),inon the new one; a scheduled swap's rows are block-level events, its Withdraw / Depositsystem_eventlegs without an amount. A pre-dTAO stake (to block 4,920,349) is the call's Signed origin's (self, nonetuid; e.g. a multisig), the signatory's legnone(rolestaker); atransfer_stakebetween two coldkeys is onetransfer_alphaleg on each side (nostake/unstakelegs; to the same coldkey they stay, bothself).register_networkcan sit on a registration-queue row (NetworkRegistrationQueued, v432+) as anoneleg without anetuid. 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 onclass). 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,selfornone. Transfers (TAO, alpha, a coldkey swap) arein/out(selfwhen the account is both sides). Stake, unstake, moving or swapping stake and basket deposits / claims areselffor 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 arenone, with the staker ascounterparty(rolestaker). An emission deposit isin; burned / recycled alphaoutfor its coldkey; a stake burnoutfor the account that signed it (nonefor anyone else); an auto-stakeinfor its owner. A root claim isselffor the claiming coldkey (or the signer).reserve/unreserveareselffor the holder (free and reserved are both the account's);repatriate_reserveandstorage_depositoutfor the paying side andinfor the receiving one;dust_lostoutfor the reaped account;stake_lockselffor the coldkey andnoneon the hotkey (staker ascounterparty). A basket rebalance, weights, children, take, registration, identity, EVM,otherandsystem_eventarenone, except aregister_neuronleg 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 isoutwith 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) staynone.subnet_lockisself(free to locked) before block 6,573,966 andoutfrom it,subnet_lock_refundself(locked to free) orin(an escrow refund),dissolve_payoutin.fee_incomein;crowdloan_contributeout,crowdloan_withdrawin, the other crowdloan classesin,outorselfby which side of the fund the account is;lp_add/lp_removeselffor the provider andnoneon the hotkey (roleliquidity_provider),lp_disabledself(the position back to free); a pre-dTAO stake isselffor the call's signed origin (e.g. a multisig),nonefor the signer and the hotkey (the origin ascounterparty, rolestaker); atransfer_staketo another coldkey istransfer_alphaout/inonly (nounstake/stakelegs); astake_burnisnone; acoldkey_swapouton the old key andinon the new.account_created/account_reapedareselffor the account; the proxy, pure proxy and multisig legs,commitment,serve_axon,limit_order_skippedandbasket_claim_dust_skippedarenone(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.1is 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_indexis reduced to its subnet). Always present: null when the event has none.- amountobject · can be null
What the leg moved (or, on a
stake_lockleg, locked:is_flowfalse), each amount with its source. Always present: null when it moved no amount (weights, children, identity, other, theaccountgroup,commitmentandserve_axon); never0for no amount.- swap_feevalue · optional
Only on
stake/unstakelegs: 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'stx_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 aroot_claimunless the claim went through exactly one basket).- opstring · optional
Only on
weightslegs:set,commitorreveal. Absent on every other leg. New values may be added; show an unknown value as is (or generically).- takestring · unit ratio · optional
Only on
takelegs: 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_neuronlegs: 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_heightfor 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 (netuidnull) or the slot has no recorded life (root).- life_start_heightinteger · unit block · can be null
The first block of the life
generationnames (GET /subnets/generations'start_height): use it, nevergeneration, for heights, ages and dates. Null exactly whengenerationis null (root without a life, no subnet), or transiently when this API cannot read the lives. Root'sgeneration0 starts at 0.- is_current_lifeboolean · can be null
Whether
generationis the slot's current life (true) or an ended one, re-registered since (false). Null exactly whengenerationis null, or transiently when this API cannot read the lives. Root'sgeneration0 is current.- destination_generationinteger · unit id · can be null · beta
Beside
destination_netuidonly: the destination subnet's life at the row's block (a move), an opaque life id likegeneration, NOT a block height. Absent withoutdestination_netuid, and where the source states no life for it (root).- destination_netuidinteger · unit id · optional
Only on
transfer_alpha,move_stake,swap_stakeandbasket_rebalancelegs: the subnet the alpha went to (netuidis where it came from). Absent when the event does not name one.- dust_sweepobject · can be null
Only on the feed account's own
unstakelegs (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_raois 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 andtao_raois"0". Total TAO received for this unstake =amount.tao_rao+dust_sweep.tao_rao.- callvalue · optional
Only on
otherlegs: the extrinsic's own call, which nothing classified for the account.- balance_fromenum · optional
Only on
reserve/unreservelegs: the account's balance the TAO left (freefor a reserve,reservedfor an unreserve). A reserve moves TAO between two balances of the same account: a deposit is held, not spent, and is no outflow. Alsofreeon aselfsubnet_lock(before block 6,573,966),lockedon aselfsubnet_lock_refund, andlp_positionon the provider'slp_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_reservelegs: the balance the TAO entered (reservedfor a reserve,freefor an unreserve; on a repatriation the event's status, the receiving account's free or reserved balance). Alsolockedon aselfsubnet_lock(the owner's lock, refundable),freeon aselfsubnet_lock_refund, andlp_positionon the provider'slp_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 onstorage_deposit) orother(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
reasonwas read from,Pallet.call_nameas 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_claimlegs: the claim per basket, from the extrinsic's BasketClaimed events for the coldkey, in event order; present only when they sum exactly toamount.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_skippedandstake_burnlegs (onstake_burn, whose TAO and alpha are thestakeandburn_alphalegs'), alwaysfalse: 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_killedlegs: 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_removedlegs: 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_*andproxy_announcedlegs: 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_feelegs: whether the real account now pays its proxy's transaction fees. Absent (never null) on every other leg.- successboolean · optional
Only on
multisig_executedlegs: 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
commitmentleg: 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_skippedlegs: 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 ascounterparty(roleorder_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_skippedlegs: 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_skippedlegs: how many claim rows the runtime skipped as dust. Absent (never null) on every other leg.- forfeited_estimatevalue · optional
Only on
basket_claim_dust_skippedlegs: the TAO the skipped rows were worth, as the event estimates it, with its source. Not an amount: nothing moved (the leg has noamountandis_flowis 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_sourceevent), else its alpha at the pool's price at the block (spot; root 1:1). Null whenunpriced, and on an older answer. Present only beside anamount.- Format: whole number, as a string
- value_sourcestring · can be null
Where
value_tao_raocomes from: the leg's own TAO amount, with that amount's own source (value_source=amount.tao_source, soevent,trace(e.g. aregister_neuronburn) orderived(a burn before block 223,049: approximate); alwayseventon 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) orunpriced(no price: both values null). Null on an older answer. Present only beside anamount. New values may be added; show an unknown value as is (or generically).- value_usdstring · unit usd · 6 decimals · can be null
value_tao_raoin USD at TAO/USD at the block's time. Null whenvalue_tao_raois or no TAO/USD price exists, and on an older answer.- Format: decimal number, as a string
- sourcestring · optional
Only on a
feeleg:gas_fee, the leg is the row's EVM gas fee (TAO withdrawn minus refunded on the payer,out, its amount exactlygas_fee.amount_rao;call_idthe row's id). Exactly one on every row with a non-nullgas_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'stx_fee). New values may be added; show an unknown value as is (or generically).- units_invalue · optional
Only on
basket_stake_inlegs: the fund units the stake bought (the event's shares). The TAO paid is the leg'samount.tao_rao(directionout). 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_payoutandsubnet_lock_refundlegs: the block the paying subnet life ended (dissolved). Withnetuidandgeneration(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_incomelegs (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 ascounterparty, rolepool) orgas_fee(an EVM gas fee). Income to the author; the payer's own fee is unchanged (its row'stx_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_removelegs (the provider's and the hotkey's): the liquidity position's id (decimal string). Absent (never null) onlp_disabledand every other leg.- Format: whole number, as a string
- lp_feesvalue · optional
Only on
lp_add/lp_removelegs 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'samountor 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_swapleg (out): what the swap cost it (amount_raoinassettao, 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);
0when 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_raowhen 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_raois minus (tx_fee.amount_rao+tx_fee.tip_rao), the chain's actual fee, when the account paid the fee in TAO, else0. Null on an older answer.- is_dustboolean · can be null
The row has a
dust_lostleg (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 (root1; null where the subnet has no price), keyed exactly by thenetuidanddestination_netuidof every leg with anamount(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'spotvalues.{}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 (everyvalue_usdis then null too), and on an older answer.- Format: decimal number, as a string
- generation_by_netuidobject · can be null
{netuid: generation}: the life each subnet a leg names (netuidordestination_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' owngeneration(adissolve_payoutorsubnet_lock_refundnames 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
incomerows (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
netuidfilter's own index, so the filter and the row agree; empty when none does; absent on an older answer). Only onextrinsicrows (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 onextrinsicrows (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
extrinsicrows (absent on the others).- callvalue · optional
The extrinsic's own (top-level) call. Only on
extrinsicrows (absent on the others).- successboolean · optional
Whether the extrinsic succeeded. Only on
extrinsicrows (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 forEthereum.transact. So summingtx_feeover one account's feed counts each fee it paid exactly once. Only onextrinsicrows (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 bysigner.- Format: SS58 address
- assetstring
What the fee was paid in:
tao, oralphaofnetuid(TransactionFeePaidWithAlpha: the fee extension sold the payer's alpha to pay it). It namesamount_rao's denomination. New values may be added; show an unknown value as is (or generically).- netuidinteger · unit id · can be null
When
assetisalpha: the subnet whose alpha paid. Null fortao.- amount_raostring · unit rao (÷1e9)
The fee in the paid asset's base unit (decimal string), the tip excluded: rao when
assetistao, alpha rao ofnetuidwhenassetisalpha(a mixed-denomination field:x-unitkeepsraoas the 1e9 scale andassetnames the denomination; never add an alpha amount to TAO). In TAO: TransactionFeePaid.actualFee - tip; in alpha: TransactionFeePaidWithAlpha.alphaFee. The whole fee in TAO terms isamount_rao + tip_raofortao,tao_equivalent_rao + tip_raoforalpha.- 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
assetisalpha: the TAO the alpha sale realized to pay the fee, rao (TransactionFeePaidWithAlpha.taoAmount); always present on an alpha fee. Null fortao. The fee's cost in TAO terms istao_equivalent_rao + tip_rao, but no TAO left the payer for it: never add it toamount_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_raofortao; foralphaitstao_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_raoin 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_raoamounts, 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.callcan show itstx_feeon the signer's feed and itsgas_feeon the mapped account's: each fee on exactly one feed. Only onextrinsicrows (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 thetx_feepayer (a signedEVM.callcharges its signer the Substrate fee and the mapped account the gas). Group fees bypayer.- Format: SS58 address
- fromstring
The H160 sender, 0x + 40 lower-case hex, as the EVM transaction or call names it (not rendered;
payeris 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, everySudocall,Multisig.as_multi/as_multi_threshold_1): what it dispatched, counted by kind, and the proxied account. Null for every other call. Only onextrinsicrows (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.transactextrinsic's EVM transaction hash, 0x + 64 lower-case hex; null on every other extrinsic. Only onextrinsicrows (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_attemptthat 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_attemptwhose 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; anas_multi_threshold_1too),cancelled(MultisigCancelled) orfailed_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
storagerows: 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
storagerows: 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
storagerows: the changed storage key, 0x + lower-case hex.- Format: hex: 0x and hex digits
- addressobject
The account whose feed the row came from, as
{ss58, hex}. A row touching two of the accounts appears once per account (each with its ownrole, events and classification), ordered byaddress.2 fields in address
- 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
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), slowpublic, max-age=300, stale-while-revalidate=600(state that moves in minutes or days) or tippublic, 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). Neverimmutable.no-storeon 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-revalidateandstale-if-error;no-storewithX-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, withX-BTAI-Stale-As-Of,Age(its seconds since then) andWarning: 110 - "Response is Stale", andCache-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.
- ADDRESSES_REQUIRED
- ADDRESS_NOT_IN_PLAN_SCOPE
- AMBIGUOUS_CREDENTIALS
- BAD_GATEWAY
- BATCH_TOO_LARGE
- BILLING_UNAVAILABLE
- BUDGET_EXCEEDED
- CONCURRENCY_LIMIT
- CURSOR_STUCK
- INSUFFICIENT_PERMISSIONS
- INTERNAL_ERROR
- INVALID_ADDRESS
- INVALID_CALL
- INVALID_CLASS
- INVALID_CURSOR
- INVALID_EVENT
- INVALID_GROUP
- INVALID_HEIGHT
- INVALID_INCLUDE
- INVALID_LIMIT
- INVALID_ORDER
- INVALID_PALLET
- INVALID_RANGE
- INVALID_SOURCE
- INVALID_TIME
- NOT_READY
- PAYMENT_REQUIRED
- RATE_LIMITED
- REPEATED_PARAMETER
- SERVICE_UNAVAILABLE
- SOURCE_BUSY
- SOURCE_NOT_READY
- SOURCE_TIMEOUT
- UNAUTHORIZED
- UNKNOWN_CALL
- UNKNOWN_EVENT
- UNKNOWN_PARAMETER
- VALIDATION_ERROR
From the API's published specification, version 1.165.0.