Skip to content
TAO$188.32
BTC0.002928
MCap$2.22B
Vol$86.25M

API reference / Accounts

Balances and stake of an account

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

The account ({ss58, hex}), its TAO balances (free, reserved, frozen, transferable), its stake valued at spot, a root staker's basket entitlement (basket_entitlement, valued at the funds' spot NAV as of the latest available day end: unrealized, its own figure), with totals and USD twins, at one block.

Full description

The account ({ss58, hex}), its TAO balances (free, reserved, frozen, transferable), its stake valued at spot, a root staker's basket entitlement (basket_entitlement, valued at the funds' spot NAV as of the latest available day end: unrealized, its own figure), with totals and USD twins, at one block. total_spot_tao_rao is settled value only and never null: free + reserved + the priced stake (never the basket entitlement), with total_is_lower_bound true when a position has no price (positions_unpriced). Exact inside meta.coverage. One call per page view: include adds the account page's sections (identity, owned, proxies, roles, security, evm, the positions, the activity feed's first page and its counts; caps and costs under include), all at the one meta.at, each section with a meta of its own in meta.sections.<name> (accounts SS58 throughout). A section of the account read that fails fails the whole call; the page members read beside it (series_30d, hotkey, label) fail on their own (null with a reason). meta.settled is meta.at.finalized; the answer is cached as settled only when it is pinned (at a height or hash) and no section follows the head. account_kind says what the account is from its bytes (custody: a module account holding other accounts' funds, such as a subnet pool account or the basket escrow; protocol: another module account; account: no module prefix), with the registry's name when known. Errors are application/problem+json: INVALID_ADDRESS, INVALID_AT, INVALID_INCLUDE, INVALID_CHILD_LIMIT, INCLUDE_AT_HEAD_ONLY (identity / owned / proxies / roles / security / evm with an at below the head; series_30d / hotkey / label with any at), AT_OUT_OF_COVERAGE, BLOCK_NOT_FOUND (404), NOT_READY (503, a counts window starting below the indexed blocks), UNKNOWN_PARAMETER, SOURCE_TIMEOUT (503), SOURCE_NOT_READY (503).

Path parameters

addresspath, required· string

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

Query parameters

atquery· string

The block the answer is for: a block height (9179640), a 0x block hash, or an RFC 3339 time (2026-09-30T10:00:00Z, resolved to the last block at or before it). Omitted: the latest block the source has processed. Block 0 (the genesis block, by height or hash) is a 400 INVALID_AT: it has no timestamp. A time the indexed head has not reached yet (in the future, or not indexed yet) is a 503 NOT_FINAL with Retry-After, never an answer at an earlier block.

Format: a block height, a 0x block hash, or an RFC 3339 time
includequery· string

Sections to add (one call per page view), a comma list (or the parameter repeated); each is absent without it. Every section answers at the response's one meta.at. Anything else is a 400 INVALID_INCLUDE.

includeaddscap
identitydata.identity: the on-chain identityone object
owneddata.owned: its hotkeys (each with its take, stake at spot and share holders), the subnets it owns (with their name, symbol, price, pool and neurons), past subnet livesunpaged
rolesdata.roles: key type; the subnets where it or a hotkey it owns validates, actively validates or mines; delegate; associated EVM addressesone object
securitydata.security: balance holds, freezes and locks, a pending coldkey swap (with coldkey_swap.disputed_at_block, read from chain state beside the account), auto-stake destinationsone object
evmdata.evm: mirror, the H160 whose Frontier mirror account (blake2_256("evm:" ++ h160)) IS this account, known only when that H160 was observed in an EVM transaction (null = not observed, never "has none"); associations, the AssociatedEvmAddress entries of its own uids as a hotkey (unrelated to the mirror)one object
multisigdata.multisig: as_multisig (the account as a multisig, as GET /multisigs/{account} answers it, plus its open operations' keys newest first; null = not known as one, never "not a multisig"), as_signatory (the multisigs whose verified signatories include it: threshold, signatory count, open operations), awaiting_approval (their open operations it has not approved, newest first); accounts as {ss58, hex}one object
proxiesdata.proxies: its proxies, the accounts that made it theirs (first 100), pending multisig operations; the proxy announcements it made (announcements, announcement_deposit_rao) and those its proxies made to run as it (incoming_announcements), read from chain state beside the account100 delegators
positionsdata.positions: the first child_limit stake positions at meta.at in (netuid, hotkey) order (position_count counts them all); meta.sections.positions (truncated, page.next_cursor)child_limit (default 100)
activitydata.activity: the feed's first 50 rows at or below meta.at; meta.sections.activity50 rows
counts_24hdata.activity_counts.24h: the activity counts of the 24 h ending at meta.at; meta.sections.counts_24hone object
counts_7d / counts_30ddata.activity_counts.7d / .30d; meta.sections.counts_7d / counts_30done object
exiteach data.positions[].exit; data.exit_by_netuid (null when the positions section is truncated). Needs positions (else 400 INVALID_INCLUDE); no meta.sections memberas positions
auto_stakedata.auto_stake: the coldkey's auto-stake destinations (AutoStakeDestination), [{netuid, hotkey: {ss58, hex}}] by netuid (netuid null = every subnet, the runtime 315-323 form, only before block 6,608,229); meta.sections.auto_stakeone row per subnet
series_30ddata.series_30d: the last 30 days of balances and value, as GET /accounts/{address}/series answers with its default window; meta.sections.series_30d30 days (+ the open row)
hotkeydata.hotkey: the address as a hotkey, as GET /hotkeys/{address}?include=subnets answers it; null with not_a_hotkey for an address that is not one; meta.sections.hotkeyone object
labeldata.label: the address's own label and entity, as GET /labels/{address} answers them; meta.sections.labelone object

The page members (series_30d, hotkey, label) are read in parallel with the account, so a page that asks for all of them waits for the slowest read rather than the sum. Each fails on its own: a read that fails, is not ready or takes longer than 8 s serves its member null with meta.sections.<name>.unavailable_reason, and the rest of the answer is served. meta.sections.<name>.meta is the meta its own route answers with. They are head only (with an at, a 400 INCLUDE_AT_HEAD_ONLY) and an answer carrying one is cached as a head answer (tip).

exit: what selling each position back to TAO would realize now, computed by this API with the chain's exact swap on each held subnet's pool at the head (one more read of those pools): realizable_tao_rao, spot_value_tao_rao of the same alpha, fee_alpha_rao, exit_to_spot_ratio (availability: realizable / spot) and impact_ratio (the sale's own price move; a different figure). It sells the sellable alpha only. The conviction lock is the account's, one per subnet (subnet_locks), capping its whole alpha there; only miner collateral (collateral_locked_alpha_rao) is per position. A position on a subnet without a conviction lock sells alpha_rao - its collateral (basis unlocked); one on a subnet under a lock sells min(its alpha - its collateral, the subnet's sellable_alpha_rao) (basis subnet_lock_capped): exactly the most that position ALONE can sell, but the subnet's positions share that amount, so their sold alpha does not add up either (read exit_by_netuid, which sells the subnet's sellable_alpha_rao once; the positions route reads the same locks from meta.subnet_locks). On an older data version's answer the exit sold alpha_rao - locked_alpha_rao. A position whose lock or collateral is not known (locks_known false) has a null exit (locks_unknown), and on an answer older than the locks (locks_known null) the exit sells the whole position, flagged basis = whole_position_locks_unknown (not the unlocked exit). Root exits 1:1 with no fee. A pool the model does not cover, a subnet without one or staking disabled: null figures with unavailable_reason. Each position's exit assumes that position alone is sold: exits are liquidity, not value, and do not add up (two hotkeys on one subnet sell into one pool); exit_by_netuid applies the curve once per subnet. Head only (400 INCLUDE_AT_HEAD_ONLY with at), tip-cached.

proxies' announcements and security's disputed_at_block come from one chain-state read after the account's (at the state head): meta.sections.<proxies|security>.state_read says where, or why those members are null (not_ready: not deployed on this data source yet; source_unavailable); the rest of the answer is served either way. auto_stake is its own chain-state read, at meta.at when the answer is pinned (at; not head only) and at the state head otherwise; null with meta.sections.auto_stake.unavailable_reason when unavailable, and a pinned answer whose read failed is not cached as settled. identity, owned, proxies, roles, security, evm and multisig are current state: with an at below the head they are a 400 INCLUDE_AT_HEAD_ONLY, and an answer carrying one is cached as a head answer (tip). So are the counts (like /activity/counts). 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).

Every include describes itself in meta.sections.<include> (its data_version; coverage or source; page and truncated where capped).

Metering: the route's weight (3) plus each include's own: roles +1, security +1, evm +1, multisig +1, positions +1, activity +1, counts_7d +1, counts_30d +2, exit +1, series_30d +1, hotkey +2; identity, owned, proxies, auto_stake, counts_24h, label and names +0.

child_limitquery· integer · default 100 · 1 to 1000

Positions in the positions section, 1..1000 (default 100, the data source's own); anything else is a 400 INVALID_CHILD_LIMIT. The section is GET /accounts/{address}/positions?limit=<child_limit>'s first page at meta.at, so its meta.sections.positions.page.next_cursor continues that route called with the same limit (a cursor is bound to the account and limit and answers at this response's block). Ignored without include=positions.

owned_limitquery· integer

Owned hotkeys in owned.hotkeys, 1..1000 (default 100; sent only when given); anything else is a 400 INVALID_LIMIT. owned.hotkeys_total counts them all and meta.sections.owned.page.next_cursor continues the list. Ignored without include=owned.

owned_cursorquery· string

The previous answer's meta.sections.owned.page.next_cursor (bound to the account and owned_limit; sent only when given); a cursor the data source does not recognise is its 400 INVALID_CURSOR.

Response

data is an object 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.

The account.

addressobject

The account, as {ss58, hex}.

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
account_existsboolean

False when the chain has no System.Account entry at meta.at (never created, or reaped); the balances are then a measured 0.

free_raostring · unit rao (÷1e9)

Free balance (System.Account data.free), in rao.

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

Reserved balance (data.reserved), in rao.

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

Frozen balance (data.frozen), in rao.

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

free - frozen, floored at 0, in rao.

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

The priced positions at spot: the sum of their value_spot_tao_rao (alpha x spot price), in rao. A spot valuation, not an exit value. Never null: positions_unpriced counts the positions left out, and total_is_lower_bound says so.

Format: whole number, as a string · on chain: u64
position_countinteger · unit count

Number of stake positions at meta.at (all of them, also when the positions section is cut at child_limit; /accounts/{address}/positions lists them).

positions_unpricedinteger · unit count

How many of those positions have no spot price at meta.at (their value_spot_tao_rao is null). Above 0, stake_spot_tao_rao and total_spot_tao_rao leave them out and total_is_lower_bound is true.

basket_entitlementobject · can be null

What a root staker is owed by its root validators' v441 basket funds (root dividends held in escrow), valued at spot, as of the latest available UTC day end at or below meta.at (it lags the head by up to a day: as_of_day / as_of_height). Unrealized and its own figure: never in total_spot_tao_rao (claiming costs fees and has a threshold). Null when no units are owed (every account that is no root staker) or no day is available at or below meta.at.

7 fields in basket_entitlement
owed_unitsstring · unit shares

The fund units it is owed, summed over its funds, at as_of_day.

Format: whole number, as a string
spot_tao_raostring · unit rao (÷1e9)

Those units valued at each fund's spot NAV per unit at as_of_height (the NAV's close anchor: spot_nav / units), floored per fund, summed, in rao of TAO: a spot valuation, not what a claim would pay. Only the valued funds: unvalued_funds counts the rest (0 when none is valued). Never part of total_spot_tao_rao.

Format: whole number, as a string · on chain: u64
basisstring

How spot_tao_rao is valued: basket_nav spot, each fund's spot NAV per unit. New values may be added; show an unknown value as is (or generically).

fundsinteger · unit count

Basket funds that owe it units (each > 0).

unvalued_fundsinteger · unit count

Of those, the funds without a NAV at as_of_height: left out of spot_tao_rao.

as_of_daystring (date)

The UTC day end the entitlement is read at: the latest available day whose last block is at or below meta.at (it lags the head by up to a day).

Format: date, YYYY-MM-DD
as_of_heightinteger · unit block

That day's last block: where the units and NAVs are read.

basket_entitlement_missingboolean

True for a root staker (root stake > 0 at meta.at) whose basket entitlement isn't available yet for that block (basket_entitlement null). It never affects the total (the entitlement is never in it). False otherwise, including for every root staker whose entitlement is served.

total_spot_tao_raostring · unit rao (÷1e9)

Settled value only: free + reserved + the priced stake (stake_spot_tao_rao), in rao (the basket entitlement is never included; it is basket_entitlement). Never null: when total_is_lower_bound it is the known part, a lower bound.

Format: whole number, as a string · on chain: u64
total_is_lower_boundboolean

True exactly when a position has no price (positions_unpriced > 0): total_spot_tao_rao (and total_spot_usd) then leave it out, the known part only. Show the total as 'at least'. (A missing or unvalued basket entitlement never touches the total.)

free_usdstring · unit usd · 6 decimals · can be null

free_rao in USD at meta.tao_usd (6 decimals); null exactly when meta.tao_usd is.

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

stake_spot_tao_rao in USD at meta.tao_usd (6 decimals); null exactly when meta.tao_usd is.

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

total_spot_tao_rao in USD at meta.tao_usd (6 decimals): a lower bound with it. Null exactly when meta.tao_usd is (no TAO/USD price for that minute), never because a member is unknown.

Format: decimal number, as a string
total_incl_unclaimed_spot_tao_raostring · unit rao (÷1e9) · can be null

Total including unclaimed root rewards (pending_tao_rao): not yet claimed and not liquid until claimed; the plain total excludes them. total_spot_tao_rao + pending_tao_rao, in rao. The unclaimed part is the root funds' entitlement claimable at the same block, at each fund's latest realizable NAV; a lower bound with total_is_lower_bound. Null when either part is null (an unknown unclaimed amount never counts as 0); equal to total_spot_tao_rao when pending_tao_rao is 0. Computed by this API from the served fields.

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

Total including unclaimed root rewards (pending_tao_rao): not yet claimed and not liquid until claimed; the plain total excludes them. total_incl_unclaimed_spot_tao_rao in USD at meta.tao_usd, the price total_spot_usd uses (6 decimals, half away from zero). Null when either is null; equal to total_spot_usd when pending_tao_rao is 0. Computed by this API.

Format: decimal number, as a string
locked_spot_tao_raostring · unit rao (÷1e9) · can be null · beta

The stake's locked part at spot, in rao: part of stake_spot_tao_rao, never added to it. Every subnet lock at min(subnet_locks[].locked_alpha_rao, subnet_alpha_rao) (a lock above its holdings, exceeds_holdings, counts only the stake it binds) plus every position's collateral_locked_alpha_rao, each at its subnet's price; on an older data version's answer, each position's locked_alpha_rao x its price. Null when a lock or collateral is not known, a locked amount is unpriced, and on an older answer.

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

Whether every lock and collateral of the account is known (locked_spot_tao_rao null when not). Null on an older answer (locks not served).

subnet_locksarray of objects · can be null · beta

The account's conviction locks, one per subnet, each binding its WHOLE alpha on the subnet, with what is sellable there (sellable_alpha_rao); [] when none. A conviction lock is never a position's: positions carry only their miner collateral (collateral_locked_alpha_rao). Null on an older answer (there the lock was attributed to a position, positions[].locked_alpha_rao).

12 fields in subnet_locks (each item)
netuidinteger · unit id

The subnet slot the lock is on.

hotkeystring

The conviction TARGET (the lock's third key), SS58 (prefix 42). Not where the locked alpha sits: the lock binds every position of the account on the subnet, and the account may hold none on this hotkey (target_position_held).

Format: SS58 address
locked_alpha_raostring · unit alpha_rao (÷1e9) · can be null

The lock's mass at meta.locks_as_of_height after decay (locked_mass x exp(-(height - last_update) / UnlockRate), or the mass itself when perpetual; within 1 rao of the runtime's I64F64 exp), in alpha rao. Served as the chain holds it, never clamped: above subnet_alpha_rao only with exceeds_holdings. Null when the lock does not decode (locks_known false).

Format: whole number, as a string · on chain: u64
perpetualboolean

True when the lock does not decay (DecayingLock(coldkey, netuid) false).

last_update_heightinteger · unit block · can be null

The block the lock's decay clock was last reset at. Null when not known.

subnet_alpha_raostring · unit alpha_rao (÷1e9)

The account's alpha on the subnet at the block, every position there summed, in alpha rao: what the lock binds (never one position).

Format: whole number, as a string · on chain: u64
target_position_heldboolean

Whether the account holds a position on the target hotkey on this subnet.

exceeds_holdingsboolean · can be null

True when the chain holds a lock above the account's alpha on the subnet (locked_alpha_rao > subnet_alpha_rao): served as is, never clamped; nothing on the subnet is then sellable. False otherwise. Null when the lock is not known.

sellable_alpha_raostring · unit alpha_rao (÷1e9) · can be null

What the account can unstake on the subnet now: max(subnet_alpha_rao - locked_alpha_rao - the subnet's positions' collateral_locked_alpha_rao, 0), in alpha rao. One amount for the whole subnet, shared by its positions. Null when the lock or a collateral there is not known.

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

The lock's conviction rolled forward to meta.locks_as_of_height (LockState.conviction, U64F64, floored; the runtime's roll_forward_lock, equal to StakeInfoRuntimeApi.get_coldkey_lock): it grows toward the mass while the lock is held (MaturityRate) and, on a lock on the subnet owner's hotkey, equals the mass. In alpha rao. A measure of commitment, never an amount held or sellable, never in a total. Null when the lock does not decode, and on an older data-source answer.

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

How the lock unwinds from the block if nothing is added or moved (null exactly when perpetual: a perpetual lock never decays; checked). Null too when the lock does not decode, and on an older data-source answer.

3 fields in decay
tau_blocksstring · unit blocks

UnlockRate, the decay timescale in blocks (live; default 934,866), a u64 string.

Format: whole number, as a string
half_life_blocksstring · unit blocks

round(tau_blocks x ln 2): blocks for the lock to halve (648,000 at the default, about 90 days).

Format: whole number, as a string
schedulearray of objects

The mass after 30, 90, 180 and 365 days, in that order (exactly those four; checked).

exitobject · can be null

How the locked alpha leaves the lock: speed decay (the mass decays into unlocked alpha stake on the same subnet, lands_as alpha_stake, at cost_ratio 0, exact: no fee, the cost is time) or none while perpetual (cost_unavailable_reason no_exit); no hold (checked). Null on an older data-source answer.

6 fields in exit
speedstring

instant: one extrinsic; claim: a claim that restakes on root; decay: a lock decaying into unlocked stake; none: not withdrawable while it holds (a perpetual lock). New values may be added; show an unknown value as is (or generically).

hold_blocksstring · unit blocks · can be null

Blocks before the exit can run, a u64 string: 0 on subnet stake; on root stake RootStakeUnlockInterval at the head. Null with decay / none, and on root when the interval could not be read (the hotkey runs no fund to read it from).

Format: whole number, as a string
lands_asstring

Where the proceeds land: free TAO, root stake on the same hotkey, or alpha stake. Known values: free_balance, root_stake, alpha_stake, none. New values may be added; show an unknown value as is (or generically).

cost_ratiostring · unit ratio · can be null

1 - proceeds / value given up, at this amount, now (transaction fees excluded), 8 decimals; 0 on a decaying lock (no fee: the cost is time). Null exactly with cost_unavailable_reason (checked: exactly one of the two is set).

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

Whether cost_ratio is the cost (exact) or the most it can be. Null with no cost_ratio. Known values: exact, upper_bound. New values may be added; show an unknown value as is (or generically).

cost_unavailable_reasonstring · can be null

Why cost_ratio is null: on a swap exit swap_refused, pool_not_alive (the subnet's subtoken is disabled), or the swap model's no_state / mechanism_unknown / unsupported_mechanism / inputs_missing; no_exit where nothing comes out (a perpetual lock, a miner collateral). Null exactly when cost_ratio is given. Known values: swap_refused, unpriced_holding, pool_not_alive, deposit_model_pending, no_exit, no_state, mechanism_unknown, unsupported_mechanism, inputs_missing. New values may be added; treat unknown values as unavailable.

pending_tao_raostring · unit rao (÷1e9) · can be null · beta

The root funds' (basket) entitlement claimable at this block: the owed units at each fund's latest realizable NAV per unit, in rao. Unrealized and its own leg: never in total_spot_tao_rao or any total. 0 when known and none; null when a fund owing units has no NAV, and on an older answer.

Format: whole number, as a string · on chain: u64
pending_unitsstring · unit shares · can be null · beta

The fund units owed (BasketRate x root stake - BasketClaimed, capped at the fund's shares), summed over the funds. Null on an older answer.

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

Whether the pending entitlement is known at this block. Null on an older answer.

pending_fundsinteger · unit count · can be null · beta

How many funds owe the account units. Null on an older answer.

pending_as_of_heightinteger · unit block · can be null · beta

The block the pending entitlement is read at. Null on an older answer.

accrued_unitsstring · unit shares · can be null

The owed fund units NOT bought through stake_into_basket (pending_units - invested_units, checked): the unrealised root accrual. Never in an amount total. Null on an older answer.

Format: whole number, as a string
accrued_tao_raostring · unit rao (÷1e9) · can be null

accrued_units at each fund's latest realizable NAV per unit, rao (at most pending_tao_rao, checked). Unrealised: never in total_spot_tao_rao or any total. Null when a fund owing units has no NAV, and on an older answer.

Format: whole number, as a string · on chain: u64
invested_unitsstring · unit shares · can be null

The owed units bought through stake_into_basket since each fund's last claim (principal; an attribution). Null on an older answer.

Format: whole number, as a string
fund_principal_spot_tao_raostring · unit rao (÷1e9) · can be null

invested_units at each fund's spot NAV per unit, rao: principal, which may enter a total that states its spot basis; never the accrued part, and not in total_spot_tao_rao. Null when not known (a fund holding invested units has no spot NAV: never a partial sum; fund_principal_known false), and on an older answer.

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

Whether fund_principal_spot_tao_rao is known (false exactly when it is null: a fund holding invested units has no spot NAV). Null on an older answer.

account_kindobject

What the account is, from its bytes: a module account holding others' funds (custody), another module account (protocol) or a plain account.

4 fields in account_kind
kindstring

custody: a module account that holds other accounts' funds (the subnet pool accounts, the basket escrow, crowdloan funds, the limit-order intermediary), so its balance is not its own: leave it out of rankings of holders. protocol: any other module account. account: no module-account prefix; it may still be a multisig, a pure proxy or an EVM-mapped account (those cannot be told apart from the bytes). New values may be added; show an unknown value as is (or generically).

pallet_idstring · can be null

The module account's PalletId, the 8 bytes after the modl prefix as text (e.g. subtensr, bt/cloan). Null when kind is account.

subobject · can be null

The sub-account the bytes after the PalletId decode to. Null for a plain account, for a PalletId's base account, and for sub-account bytes that do not decode.

2 fields in sub
typestring

How the sub-account bytes decode: netuid (a subnet pool account's subnet, u16), index (a numbered sub-account such as a crowdloan fund's id, u32) or tag (8 printable bytes, e.g. beta/esc for the basket escrow). New values may be added; show an unknown value as is (or generically).

valueone of several

The decoded sub-account: an integer for netuid and index, a string for tag.

namestring · can be null

A readable name for the module account from a registry of known PalletIds (e.g. subnet pool account, basket escrow). Null when the registry does not know the account; never guessed.

identityobject · can be null

Only with include=identity (absent otherwise): the on-chain identity (SubtensorModule IdentitiesV2) and its last_change, null when the account has none. Current state, read at the head: with an at below the head the request is a 400 INCLUDE_AT_HEAD_ONLY. An answer carrying it is cached like a head answer (tip), never as settled.

10 fields in identity
namestring · can be null

The display name. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

urlstring · can be null

The website. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

github_repostring · can be null

The GitHub repository. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

imagestring · can be null

The identity's image: our copy of the image (fetched, checked and re-encoded by bittensor.ai), never the URL set on chain. Null when we hold no copy: image_unavailable_reason says why.

discordstring · can be null

The Discord handle. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

descriptionstring · can be null

A free-text description. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

additionalstring · can be null

Any additional text. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

image_unavailable_reasonstring · can be null

Why image is null: none_set (no image is set on chain), not_mirrored_yet (one is set and we hold no copy of it yet), fetch_failed (our last fetch of it failed: not found, refused, unreachable, or not a usable https URL) or unsafe_content (what it points at was refused: not an allowed image type, invalid or too large). Null exactly when image is served. New values may be added; treat unknown values as unavailable.

decodedboolean

True when every stored field is valid UTF-8; false when one is not (that field is then null).

last_changeobject · can be null

The current identity's last change, its block, cause and event (the same causes as /accounts/{address}/identity-history). cause migration means a runtime upgrade wrote it: a migration-created identity was never set by this account's key holder, so it says nothing of who holds the key. Null when no identity key change is found, and on an older answer.

3 fields in last_change
heightinteger · unit block

The block of the identity key's newest write that changed its value.

causestring · can be null

set: a SubtensorModule.ChainIdentitySet by this account (its key holder set it); coldkey_swap: the identity moved here with a coldkey swap; migration: written by a runtime upgrade's migration (e.g. the IdentitiesV2 migration at block 4,920,351): a migration-created identity was never set by this account's key holder. Null when the write has none of these (event_id null too). New values may be added; show an unknown value as is (or generically).

event_idstring · unit id · can be null

The event, {height}-{index} (/api/v2/events/{id}): the ChainIdentitySet or ColdkeySwapped in height's block, or for a migration the System.CodeUpdated that enacted its runtime, in the block before (checked). Null exactly when cause is.

Format: block and index, such as 4200000-3
ownedvalue · optional

Only with include=owned (absent otherwise): its hotkeys, the subnets it owns and how many past subnet lives it owned. Current state, read at the head: with an at below the head the request is a 400 INCLUDE_AT_HEAD_ONLY. An answer carrying it is cached like a head answer (tip), never as settled.

proxiesvalue · optional

Only with include=proxies (absent otherwise): its proxies, the accounts that made it theirs and its pending multisig operations. Current state, read at the head: with an at below the head the request is a 400 INCLUDE_AT_HEAD_ONLY. An answer carrying it is cached like a head answer (tip), never as settled.

rolesvalue · optional

Only with include=roles (absent otherwise): its key type, the subnets where it (or a hotkey it owns) validates, actively validates or mines, whether it is a delegate, and its associated EVM addresses. Current state, read at the head: with an at below the head the request is a 400 INCLUDE_AT_HEAD_ONLY. An answer carrying it is cached like a head answer (tip), never as settled.

securityvalue · optional

Only with include=security (absent otherwise): its balance holds, freezes and locks, a pending coldkey swap and its auto-stake destinations. Current state, read at the head: with an at below the head the request is a 400 INCLUDE_AT_HEAD_ONLY. An answer carrying it is cached like a head answer (tip), never as settled.

auto_stakearray of objects · can be null

Only with include=auto_stake (absent otherwise): where the coldkey's emission is staked automatically, one row per subnet it set a destination on (AutoStakeDestination), the every-subnet row (netuid null) first, then by netuid; [] when none is set. Read from chain state beside the account, at meta.at when the answer is pinned (at) and at the state head otherwise (meta.sections.auto_stake.at). Null when that read is unavailable (meta.sections.auto_stake.unavailable_reason); the rest of the answer is served either way.

2 fields in auto_stake (each item)
netuidinteger · unit id · can be null

The subnet. Null = every subnet: the one destination of runtimes 315-323 (before destinations were per subnet), served only on a read pinned before block 6,608,229, where those keys were removed.

hotkeyvalue · optional

The hotkey its emission there is staked to, SS58 and hex.

evmvalue · optional · beta

Only with include=evm (absent otherwise): the H160 whose mirror account is this account (mirror, when observed) and the account's own uid associations (associations), two unrelated links. Current state, read at the head: with an at below the head the request is a 400 INCLUDE_AT_HEAD_ONLY. An answer carrying it is cached like a head answer (tip), never as settled.

multisigvalue · optional

Only with include=multisig (absent otherwise): the account as a multisig, the multisigs it signs for, and their open operations awaiting its approval. Current state, read at the head: with an at below the head the request is a 400 INCLUDE_AT_HEAD_ONLY. An answer carrying it is cached like a head answer (tip), never as settled.

positionsarray of objects · optional

Only with include=positions (absent otherwise): the first child_limit (default 100) stake positions at meta.at in (netuid, hotkey) order, as GET /accounts/{address}/positions?limit=<child_limit> answers them (each with its income members over the same 7 available days); position_count counts them all. When meta.sections.positions.truncated, its page.next_cursor continues on GET /accounts/{address}/positions?limit=<child_limit>&cursor=... (same block).

23 fields in positions (each item)
hotkeystring

The hotkey the stake sits on, SS58 (prefix 42).

Format: SS58 address
netuidinteger · unit id

Subnet slot of the position (0 = root).

generationinteger · unit id · can be null

Opaque life id (the life's registration identifier), NOT a block height; use life_start_height for the first block. The life of the subnet occupying netuid: netuid is a reused slot and generation tells its lives apart (compare or join on it). 0 for root. Null when not recorded.

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.

share_formatstring

Which share map holds the position: legacy (U64F64 Alpha) or v2 (SafeFloat AlphaV2). Clients must accept values not documented yet.

alpha_raostring · unit alpha_rao (÷1e9)

Stake in alpha rao (1e-9 alpha of this subnet), equal to the runtime's StakeInfo stake.

Format: whole number, as a string · on chain: u64
price_taostring · unit tao_per_alpha · 12 decimals · can be null

Spot price of one alpha in TAO at meta.at (SwapRuntimeApi current_alpha_price / 1e9; 1 on root), 9 to 12 decimals (12 on current answers). Null when no pool price is known.

Pattern: ^[0-9]+\.[0-9]{9,12}$
value_spot_tao_raostring · unit rao (÷1e9) · can be null

floor(alpha x spot price), in rao of TAO. A spot valuation, not what unstaking would pay (that is exit, with include=exit). Null when the price is.

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

value_spot_tao_rao x TAO/USD at meta.at (6 decimals). Null when no TAO/USD price exists.

Format: decimal number, as a string
locked_alpha_raostring · unit alpha_rao (÷1e9) · can be null · deprecated

Deprecated: mis-attributed. Earlier data versions put the account's conviction lock on its target hotkey's position (plus the position's miner collateral), in alpha rao; but the runtime's lock is one per (coldkey, subnet) and binds the coldkey's WHOLE alpha on the subnet, so it could exceed the position and missed locks whose target holds no position. Such a lock above its position is served null with locks_known false. Now always null: read the account's subnet_locks (sellable_alpha_rao) and the position's collateral_locked_alpha_rao. Null on the oldest data versions' answers too. Deprecated: use subnet_locks / collateral_locked_alpha_rao; sunset 2027-02-15.

Format: whole number, as a string · on chain: u64
Deprecated since 2026-10-03, removed after 2027-02-15. Use subnet_locks / collateral_locked_alpha_rao instead.
collateral_locked_alpha_raostring · unit alpha_rao (÷1e9) · can be null

The position's miner collateral at meta.locks_as_of_height (MinerCollateral(netuid, hotkey, coldkey).locked, drained at each emission), in alpha rao: part of alpha_rao, never added; it cannot be sold. 0 when none. Truly per position, unlike a conviction lock (the account's subnet_locks). Null when it does not decode (locks_known false), and on an older data version's answer.

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

Whether the position's lock is known: its collateral (on an older data version's answer, locked_alpha_rao). Null on an older answer (locks not served: the exit then sells the whole position, exit.basis = whole_position_locks_unknown).

exitvalue · optional

Only with include=exit (absent otherwise; head only): what selling this position alone back to TAO would realize now. Liquidity, not value, and not additive: each figure assumes this sale alone, into the pool's head state; two sales into one pool get less than their exits summed (see exit_by_netuid).

optionenum · can be null

The option the position is: root_stake (option A's principal, netuid 0) or subnet_stake (option C, a validator pool on a subnet). Null on an older data-source answer.

One of: root_stake, subnet_stake
yieldobject · can be null

The POOL's figures over 7 days, the same for every holder of the pool: never this holder's own return (the portfolio series serves that), never added across positions. Null on an older answer.

3 fields in yield
apy_7dobject

Subnet positions: the pool's per-share APY (alpha terms, net of take, no price term); root positions: the hotkey's holder-true root accrual rate (option A, accrued: never an amount). Reasons from the staking vocabulary (not_ready until the day's figures are stored).

tao_return_7dobject

Subnet positions: (1 + y) x spot at the end / spot at the open - 1, a period return in TAO terms (the price move included). Root positions: null with not_applicable (checked).

alpha_price_change_7dobject

Subnet positions: the alpha spot's change over the 7 days (a period change). Root positions: null with not_applicable (checked).

collateralobject · can be null

The position's miner collateral beyond collateral_locked_alpha_rao (its floor, drain ratio and the emission that drives the drain), kept separate from the account's subnet_locks (never summed with them except in locked_spot_tao_rao). Null without a MinerCollateral entry (then collateral_locked_alpha_rao is 0; checked: a collateral above 0 has its entry), when the collateral does not decode, and on an older data-source answer.

4 fields in collateral
min_locked_alpha_raostring · unit alpha_rao (÷1e9)

The miner-set floor, alpha rao: the drain never releases below it, and while locked is below it the hotkey's own emission is captured into the lock first (so it can exceed collateral_locked_alpha_rao).

Format: whole number, as a string · on chain: u64
drain_ratiostring · unit ratio · 12 decimals

k: collateral alpha released per alpha of hotkey emission earned (CollateralDrainRatio, U64F64, snapshot at registration; 0..10, checked), 12 decimals.

Format: decimal number, as a string
earned_alpha_raostring · unit alpha_rao (÷1e9)

The hotkey's emission earned while the entry existed, alpha rao (what drives the drain).

Format: whole number, as a string · on chain: u64
exitobject

Always speed none, lands_as none, cost_unavailable_reason no_exit (checked): collateral is never withdrawn, it drains as emission is earned; no hold, no cost.

staking_exitobject · can be null

Root positions only: unstaking the principal, instant to free TAO after RootStakeUnlockInterval (hold_blocks), cost 0 (exact; root is 1:1). Null on a subnet position (its exit cost is this API's swap model: exit, with include=exit) and on an older answer.

6 fields in staking_exit
speedstring

instant: one extrinsic; claim: a claim that restakes on root; decay: a lock decaying into unlocked stake; none: not withdrawable while it holds (a perpetual lock). New values may be added; show an unknown value as is (or generically).

hold_blocksstring · unit blocks · can be null

Blocks before the exit can run, a u64 string: 0 on subnet stake; on root stake RootStakeUnlockInterval at the head. Null with decay / none, and on root when the interval could not be read (the hotkey runs no fund to read it from).

Format: whole number, as a string
lands_asstring

Where the proceeds land: free TAO, root stake on the same hotkey, or alpha stake. Known values: free_balance, root_stake, alpha_stake, none. New values may be added; show an unknown value as is (or generically).

cost_ratiostring · unit ratio · can be null

1 - proceeds / value given up, at this amount, now (transaction fees excluded), 8 decimals; 0 on a decaying lock (no fee: the cost is time). Null exactly with cost_unavailable_reason (checked: exactly one of the two is set).

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

Whether cost_ratio is the cost (exact) or the most it can be. Null with no cost_ratio. Known values: exact, upper_bound. New values may be added; show an unknown value as is (or generically).

cost_unavailable_reasonstring · can be null

Why cost_ratio is null: on a swap exit swap_refused, pool_not_alive (the subnet's subtoken is disabled), or the swap model's no_state / mechanism_unknown / unsupported_mechanism / inputs_missing; no_exit where nothing comes out (a perpetual lock, a miner collateral). Null exactly when cost_ratio is given. Known values: swap_refused, unpriced_holding, pool_not_alive, deposit_model_pending, no_exit, no_state, mechanism_unknown, unsupported_mechanism, inputs_missing. New values may be added; treat unknown values as unavailable.

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

The subnet's TAO reserve (SubnetTAO) now, rao: the pool's depth, a pool property. Null on root (no pool, checked), when not known, and on an older answer.

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

The subnet's alpha reserve (SubnetAlphaIn) now, alpha rao, what fv_level is computed from. Null on root (checked), when not known, and on an older answer.

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

Computed by this API from the two reserves (no other read): the pool's fair-value level (valuation standard 2026-09-23, R2): L1 when a reference sale of 10 alpha moves the price by less than 1 % and the alpha reserve holds at least 1,000 alpha; L2 when it holds at least 1 alpha; else L3 (less than 1 alpha, an alpha reserve of 0 or a TAO reserve of 0 included: a measured Level 3 value, the risk flag thin_pool). A pool property, never this holder's. Null on root, without both reserves, and on an older answer. New values may be added; show an unknown value as is (or generically).

last_income_heightinteger · unit block · can be null

The last day-end height, at or before the answer's day, with an income credit for this position: the pool's nominator dividend for every holder, and for the hotkey's Owner coldkey also its own take, miner incentive and owner cut credits. The root claimable (accrued, not yet income) and basket flush credits never count. Only the subnet's current life counts (from its first whole UTC day): a re-registered subnet's earlier life is another position. Null when none, and on an older answer.

income_legs_in_windowinteger · unit count · can be null

Those income credits over the 7 available UTC emission days ending at the answer's day (meta.income_window on /positions; the same window on the account's include=positions); 0 = none in the window (then last_income_height, if any, is older). The current life's credits only (the window starts at its first whole day when it is younger). Null (not known, never a partial count) when the window starts before the daily emission does (2026-09-06), when no emission day is available, and on an older answer.

exit_by_netuidarray of objects · can be null · beta

Only with include=exit (absent otherwise; head only): the wallet's exit per subnet, the curve applied ONCE to each subnet's combined positions (selling several hotkeys' alpha on one subnet sells into one pool), by netuid. Null when the positions section is truncated (not every position is in hand). Still liquidity, not value: never sum it into a portfolio total.

12 fields in exit_by_netuid (each item)
basisstring · can be null

What is sold. unlocked: the alpha less its conviction lock and miner collateral: on a position of a subnet without a conviction lock, its alpha less its collateral_locked_alpha_rao (on an older data version's answer: less locked_alpha_rao); on exit_by_netuid, the subnet's whole sellable alpha (under a conviction lock, subnet_locks[].sellable_alpha_rao). subnet_lock_capped (a position only): the position sits on a subnet under the account's conviction lock, which binds the whole subnet; it sells min(its alpha - its collateral, the subnet's sellable_alpha_rao): exactly the most this position alone can sell now, but shared: the subnet's positions draw on one sellable amount, so their alpha_sold_rao do not add up (read exit_by_netuid). whole_position_locks_unknown: the whole position, because the locks are not served yet; not the unlocked exit, which may be smaller. Null when nothing could be sized. New values may be added; show an unknown value as is (or generically).

alpha_sold_raostring · unit alpha_rao (÷1e9) · can be null

The alpha the exit sells, in alpha rao. Null when it is unknown (unavailable_reason).

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

The alpha left out of the sale, in alpha rao: the collateral and the part the subnet's conviction lock holds; alpha_rao - alpha_sold_rao. Null with basis whole_position_locks_unknown, or when unknown.

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

floor(alpha_sold_rao x the pool's spot price), in rao of TAO: the mark of the SAME alpha the exit sells. Null when unavailable.

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

The TAO the sale would pay out, after the pool fee, in rao: the chain's swap to the rao. Liquidity, not value, and not additive: each figure assumes this sale alone, into the pool's head state; two sales into one pool get less than their exits summed (see exit_by_netuid). Null when unavailable.

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

The pool fee, in alpha rao: an unstake's fee is charged in alpha, taken from the alpha going in. 0 on root. Null when unavailable.

Format: whole number, as a string · on chain: u64
exit_to_spot_ratiostring · unit ratio · 12 decimals · can be null

realizable_tao_rao / spot_value_tao_rao (12 decimals): availability, how much of the mark one sale gets out (fee and curve together); not the price impact. 1 on root. Null when unavailable or nothing is sold.

Format: decimal number, as a string
impact_ratiostring · unit ratio · 12 decimals · can be null

1 - spot price after the sale / spot price before (12 decimals): how far this sale moves the pool's price (the sale's own swap; the fee's fee-free sale after it is not included). 0 on root. Not 1 - exit_to_spot_ratio. Null when unavailable.

Format: decimal number, as a string
state_heightinteger · unit block · can be null

The block of the pool state the exit is computed on (the head). Null on root or when none.

unavailable_reasonstring · can be null

Why the figures are null, else null: no_pool (no pool state for the subnet), no_state, inputs_missing, mechanism_unknown, unsupported_mechanism (a pool the API does not model), subtoken_disabled (staking disabled on the subnet), swap_refused (the chain would refuse the swap), locks_unknown (the locks are stated but not known), locked_exceeds_total, mixed_lock_basis, no_alpha. Clients must accept values not documented yet. Never a guess (a failed pool read fails the whole call).

netuidinteger · unit id

The subnet slot.

positionsinteger · unit count

How many of the answer's positions sit on this subnet.

activityarray of objects · optional

Only with include=activity (absent otherwise): the activity feed's first page at meta.at, the newest 50 rows at or below meta.at.height, as GET /accounts/{address}/activity?to_height=<meta.at.height>&limit=50 answers them. meta.sections.activity.page.next_cursor continues that request.

30 fields in activity (each item)
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.

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).

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.

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).

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).

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
activity_countsvalue · optional

Only with a counts_24h / counts_7d / counts_30d include (absent otherwise): the activity counts per window ending at meta.at, one member per window asked for.

series_30darray of objects · can be null

Only with include=series_30d (absent otherwise): the last 30 days of balances and value, the rows GET /accounts/{address}/series answers with its default window (oldest first, the open row last when served). Null when that read is unavailable (meta.sections.series_30d.unavailable_reason); the rest of the answer is served either way. Head only: with an at the request is a 400 INCLUDE_AT_HEAD_ONLY, and an answer carrying it is cached like a head answer (tip).

87 fields in series_30d (each item)
stake_price_effect_usdstring · unit usd · 2 decimals · can be null

The day's price effect on the held stake (stake_price_effect_tao_rao on the portfolio series; on an account's series the portfolio series' figure for the same account and day) in USD at that day's tao_usd (the TAO/USD close), 2 decimals, signed. Null when the TAO figure or tao_usd is, and on an open row. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

Format: decimal number, as a string · can be negative
stake_income_incl_accrued_usdstring · unit usd · 2 decimals · can be null

The day's income including rewards earned and claimable at will, not yet claimed (stake_income_incl_accrued_tao_rao) in USD at that day's tao_usd (the TAO/USD close), 2 decimals, signed. Null when the TAO figure or tao_usd is, and on an open row.

Format: decimal number, as a string · can be negative
stake_price_effect_incl_accrued_usdstring · unit usd · 2 decimals · can be null

The day's price effect including rewards earned and claimable at will, not yet claimed (stake_price_effect_incl_accrued_tao_rao) in USD at that day's tao_usd (the TAO/USD close), 2 decimals, signed. Null when the TAO figure or tao_usd is, and on an open row. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

Format: decimal number, as a string · can be negative
stake_growth_usdstring · unit usd · 2 decimals · can be null

The day's pool growth (stake_growth_tao_rao): the rise in value per unit of the validator pools held, as rewards accrue to them (nominator dividends), excluding price moves; on an account's series the portfolio series' figure for the same account and day. in USD at that day's tao_usd (the TAO/USD close), 2 decimals, signed. Null when the TAO figure or tao_usd is, and on an open row. Null on an older data version's answer. Staking rewards in USD = stake_income_incl_accrued_usd + stake_growth_usd.

Format: decimal number, as a string · can be negative
accrued_claimable_tao_raostring · unit rao (÷1e9) · can be null

The accrued claimable at the day's close, in rao of TAO: accrued_claimable_root_tao_rao + accrued_claimable_basket_tao_rao. "0" only where nothing can be owed (before 2025-11-04, when root dividends were paid into the stake, or no root stake and no fund units). Its own figure: never in total_spot_tao_rao or the balances. Null with accrued_unavailable_reason. Accrued means earned and claimable at will, not yet claimed: from 2025-11-04 to 2026-08-02 the root claimable (alpha of each subnet, valued at that subnet's per-unit fair value at the day's close), from 2026-08-03 the units the root basket funds owe (valued at each fund's fair-value NAV per unit at the close: its holdings at fair value). Amounts below the chain's claim threshold are included.

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

The root-claimable part of accrued_claimable_tao_rao (2025-11-04 to 2026-08-02), in rao of TAO: each subnet's owed alpha at that subnet's fair value at the close. "0" on other days.

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

The basket part of accrued_claimable_tao_rao (from 2026-08-03), in rao of TAO: the fund units owed at each fund's fair-value NAV per unit at the close. "0" on earlier days.

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

The day's accrual, in rao of TAO: the claimable newly earned that day (root claimable or fund units), valued at the day's close fair value (the day's accrual is valued once a day, at the close, not at each credit's block). Income in the performance view: counted when earned, not when claimed. It includes the claimable a coldkey swap created on the new coldkey (runtime spec 334-440): other income on the swap day, never emission. Null on the first computed day and with accrued_unavailable_reason. On 2026-08-03 the root claimable was converted into basket units on chain; that day's accrual, claims, forfeits and claim cost cannot be told apart and are null (accrued_unavailable_reason conversion_day); the stock, the value, the return and the P&L are served.

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

The accrued claimable that claims released to the held stake that day, in rao of TAO (root claims at their value at the claim; basket claims: the units claimed at the close fair value). A move from accrued to held: not income and not a gain. On 2026-08-03 the root claimable was converted into basket units on chain; that day's accrual, claims, forfeits and claim cost cannot be told apart and are null (accrued_unavailable_reason conversion_day); the stock, the value, the return and the P&L are served.

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

The accrued root claimable that unstakes destroyed that day (2025-11-04 to 2026-08-02), at the close fair value, in rao of TAO: a loss. "0" on other days. root_claimable_forfeited_tao_rao keeps its own valuation (the close price). On 2026-08-03 the root claimable was converted into basket units on chain; that day's accrual, claims, forfeits and claim cost cannot be told apart and are null (accrued_unavailable_reason conversion_day); the stock, the value, the return and the P&L are served.

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

The claims' cost that day, in rao of TAO, signed (it can be negative): what the claims released at the close fair value less what they paid out. A basket claim sells the fund's holdings, so it usually pays a little less than their fair value. On a closed day of the root_claimable era (through 2026-08-02), a current answer (its fv_level_mix carries value_l3_tao_rao) also counts each root claim taken as a swap: the fair value released less the root TAO credited. An older answer serves "0" for root claims there. Keep claims cost "0", as do days without a claim. Null where the claims are not available or not priced (accrued_unavailable_reason). Inside stake_price_effect_incl_accrued_tao_rao. On 2026-08-03 the root claimable was converted into basket units on chain; that day's accrual, claims, forfeits and claim cost cannot be told apart and are null (accrued_unavailable_reason conversion_day); the stock, the value, the return and the P&L are served.

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

Why accrued figures are null; null when they are served. Given whenever accrued_claimable_tao_rao is null. not_ready: the accrued figures are not available yet for that period. unpriced: a claimable holding (or a fund holding behind it) has no fair value at the day's close (no price; on an older answer also an L3 pool): the figure is null, never a partial sum. thin_pool (an older answer only; a current answer values L3 pools): the held figures are withheld (a held stake position on an L3 pool at the day's close or the previous close, fv_reason): the price effect, P&L and returns including accrued are null; the value and the stock are served. nav_anchor_missing: the data needed to value a fund at the close is missing (a data gap, not a missing price). lp_fee_unstated: a liquidity position's fees are stated nowhere that day, so the income, P&L and returns including accrued are null. incomplete_data: another value the figure needs is unknown (the previous day's, for example). base_below_dust: the previous close's value including accrued is below 0.001 TAO, so the day's return is null (the TWR skips the day). conversion_day: 2026-08-03, the on-chain conversion of the root claimable into basket units: the day's accrual, claimed, forfeited and claim cost are null; the stock, the value, the return and the P&L are served. day_not_closed: an open row (accrued figures are stated for closed days only). An open vocabulary: clients must accept a value not listed here and show it as it is. New values may be added; treat unknown values as unavailable.

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

The performance view's value at the close, in rao of TAO: the same base as the held return (stake_return_ratio: the stake at the close price, stake_spot_tao_rao, plus the liquidity positions) plus accrued_claimable_tao_rao, the accrued claimable at its per-unit fair value. So it differs from the held base only by the accrued claimable. The value the *_incl_accrued returns are measured on; not a balance (total_spot_tao_rao stays held-only). Served whenever the accrued part is, an older answer's thin-pool day (fv_reason thin_pool) included; null when the accrued claimable or the held base is. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

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

The previous close's value_incl_accrued_tao_rao, in rao of TAO: the base of stake_return_incl_accrued_ratio. Additive across disjoint address sets. Null on the first computed day or when the previous close's value is unknown. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

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

The day's external flows in the performance view, in rao of TAO, signed: stake_net_flow_tao_rao less the basket claims' proceeds (from 2026-08-03 a basket claim moves value from accrued to held inside the portfolio; it is not money in). It also carries the accrued claimable a coldkey swap moved that day, as a transfer between the two wallets (+ into the new coldkey, - out of the old; a set holding both nets it to 0), never income or a price effect. Null when the flow is. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

Format: whole number, as a string · can be negative
stake_income_incl_accrued_tao_raostring · unit rao (÷1e9) · can be null

The day's income in the performance view, in rao of TAO, signed: stake_income_tao_rao less the root claims booked as income that day, plus accrued_income_tao_rao (root income counts when it accrues, not at the claim). On 2026-08-03 the day's accrual cannot be split out and sits in stake_price_effect_incl_accrued_tao_rao. Null on the first computed day (no previous close), when the day's or the previous close's accrued figures are unknown (accrued_unavailable_reason), wherever the held figures are withheld (on an older answer a thin-pool day, fv_reason thin_pool; accrued_unavailable_reason says thin_pool too) and on an open row.

Format: whole number, as a string · can be negative
stake_price_effect_incl_accrued_tao_raostring · unit rao (÷1e9) · can be null

The rest of the day's change in value_incl_accrued_tao_rao, in rao of TAO, signed, so that value_incl_accrued_tao_rao - stake_prev_incl_accrued_tao_rao = stake_net_flow_incl_accrued_tao_rao + stake_growth_tao_rao + stake_income_incl_accrued_tao_rao + stake_fee_tao_rao + stake_other_tao_rao + this, to the rao: the repricing of the held stake (at the close price, as in stake_price_effect_tao_rao) and of the accrued claimable (at its per-unit fair value), forfeits (also shown in accrued_forfeited_tao_rao), the claims' cost (accrued_claim_cost_tao_rao) and rounding. On 2026-08-03 it also holds the conversion's step and the day's accrual. Null on the first computed day (no previous close), when the day's or the previous close's accrued figures are unknown (accrued_unavailable_reason), wherever the held figures are withheld (on an older answer a thin-pool day, fv_reason thin_pool; accrued_unavailable_reason says thin_pool too) and on an open row. Null when the day's income is not known (income_unavailable_reason) or its earnings are not, since the price effect is what remains after income. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

Format: whole number, as a string · can be negative
stake_pnl_incl_accrued_tao_raostring · unit rao (÷1e9) · can be null

The day's gain in the performance view, in rao of TAO, signed: stake_growth_tao_rao + stake_income_incl_accrued_tao_rao + stake_fee_tao_rao + stake_price_effect_incl_accrued_tao_rao (stake_other_tao_rao excluded, as in stake_pnl_tao_rao). A claim is not a gain. Null on the first computed day (no previous close), when the day's or the previous close's accrued figures are unknown (accrued_unavailable_reason), wherever the held figures are withheld (on an older answer a thin-pool day, fv_reason thin_pool; accrued_unavailable_reason says thin_pool too) and on an open row. Null when the day's income is not known (income_unavailable_reason) or its earnings are not, since the price effect is what remains after income. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

Format: whole number, as a string · can be negative
stake_pnl_incl_accrued_usdstring · unit usd · 2 decimals · can be null

stake_pnl_incl_accrued_tao_rao in USD at that day's tao_usd, 2 decimals, signed. Null when either is. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

Format: decimal number, as a string · can be negative
stake_return_incl_accrued_ratiostring · unit ratio · 8 decimals · can be null

The day's time-weighted return in the performance view, 8 decimals, signed: (stake_growth_tao_rao + stake_fee_tao_rao + stake_price_effect_incl_accrued_tao_rao + accrued_income_tao_rao) / stake_prev_incl_accrued_tao_rao, flows at the close: the held return's base (the stake at the close price plus the liquidity positions) plus the accrued claimable at its per-unit fair value. Accrued income is in the return (it is earned on the capital held); minted service income and stake_other_tao_rao are not, as in stake_return_ratio. Null when the previous close's value including accrued is below 0.001 TAO (dust), and otherwise as stake_price_effect_incl_accrued_tao_rao. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

Format: decimal number, as a string · can be negative
stake_return_incl_accrued_usd_ratiostring · unit ratio · 8 decimals · can be null

stake_return_incl_accrued_ratio in USD terms: (1 + stake_return_incl_accrued_ratio) x tao_usd / the previous close's tao_usd - 1, 8 decimals, signed. Null when the TAO return or either rate is. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

Format: decimal number, as a string · can be negative
close_sourcestring · can be null

Where the row's figures come from (an opaque identifier): batch (a closed row from the daily close), candidate (reserved: an early close published ahead of the daily close), open (an open row: yesterday's before its close, or today's). Always given. New values may be added; show an unknown value as is (or generically).

close_as_of_heightinteger · unit block · can be null

The block the row's figures are as of: the day's last block on a closed row (day_end_height), as_of_height on an open row. Always given.

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

The Swap liquidity-provider positions AT MARK: their value at the day's close, in rao of TAO (the TAO leg plus the alpha leg at the close price). When available it replaces lp_position_cost_tao_rao in the total (lp_position_basis mark). "0" outside the LP days (2025-07-08 to 2026-01-05) and on the open rows (no position can be open); null with lp_position_spot_unavailable_reason while the mark isn't available yet. Basis: always the close mark (the alpha leg at the close price), whatever meta.valuation_standard says; the returns' liquidity sleeve uses the same mark (a disclosed departure from fair value).

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

The alpha leg of the LP positions at the day's close, in alpha rao; null and "0" as lp_position_spot_tao_rao. Basis: always the close mark (the alpha leg at the close price), whatever meta.valuation_standard says; the returns' liquidity sleeve uses the same mark (a disclosed departure from fair value).

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

The TAO leg of the LP positions at the day's close, in rao; null and "0" as lp_position_spot_tao_rao. Basis: always the close mark (the alpha leg at the close price), whatever meta.valuation_standard says; the returns' liquidity sleeve uses the same mark (a disclosed departure from fair value).

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

Why lp_position_spot_tao_rao (and its two legs) is null: not_ready (the mark isn't available yet: the total uses the cost, else 0 and total_is_lower_bound), unpriced (a pool has no close price). Only ever beside a null in its own field(s); null whenever they are served. New values may be added; treat unknown values as unavailable.

lp_position_basisenum · can be null

How the LP positions enter total_spot_tao_rao: mark (lp_position_spot_tao_rao) when available, else cost (lp_position_cost_tao_rao) when available. Neither is a lower bound (cost is not a floor on market value). The same basis values the day in the totals and in the return decomposition. Null outside the LP days (2025-07-08 to 2026-01-05), on the open rows, for an address that held no LP position that day, and when the LP counts 0 (neither figure available, or the LP kept at 0 while the mark is served for information): then total_is_lower_bound is true. A day row's basis is the weakest across its LP-holding addresses (null < cost < mark), its total their totals summed.

One of: mark, cost
stake_level3_spot_tao_raostring · unit rao (÷1e9) · can be null

The part of stake_spot_tao_rao valued at a fair-value Level-3 price (no observable pool price), in rao of TAO. RESERVED: null with stake_level3_unavailable_reason not_ready while the data isn't available yet, never 0 for unknown; it then fills with no format change. Basis: always the close price (spot), whatever meta.valuation_standard says.

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

Why stake_level3_spot_tao_rao is null: not_ready (the data isn't available yet). Only ever beside a null in its own field(s); null whenever they are served. New values may be added; treat unknown values as unavailable.

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

TAO burned from the free balance, in rao: a registration's recycled TAO (what the payer moved to the subnet account less its collateral stake), Balances.Burned, add_stake_burn's TAO. Served on a closed day whose free-flow figures are available (and on the account series' rows, which copy the portfolio row of the address and day): then every free leg of the row is served together, "0" without one. Null with free_burn_unavailable_reason not_ready on a closed day whose figures aren't available yet (every closed day of a portfolio window whose closed days are not all available: one meaning per answer), and with day_not_closed on the open rows (the free-flow group counts only at a close; the account series' open row the same); never 0 for unknown. The day's on a row or wallet; in the portfolio series' meta.totals the covered (closed) days' sum only when every covered day is available, else null with not_ready (never a partial sum).

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

Why free_burn_rao is null: not_ready (the closed day's free-flow figures aren't available yet: every closed day of a portfolio window whose closed days are not all available), day_not_closed (every open row, on both series; never a closed one). Only ever beside a null in its own field(s); null whenever they are served. New values may be added; treat unknown values as unavailable.

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

TAO into the free balance from the EVM side, in rao: EVM gas refunds, 0x800 precompile transfers received, stake removed through the staking precompile (0x805 / 0x801), bridge-escrow releases. A plain EVM value transfer between two mirror accounts is a transfer. Gas is gross: net gas = free_evm_bridge_out_rao minus the refunds. Served on a closed day whose free-flow figures are available (and on the account series' rows, which copy the portfolio row of the address and day): then every free leg of the row is served together, "0" without one. Null with free_evm_bridge_unavailable_reason not_ready on a closed day whose figures aren't available yet (every closed day of a portfolio window whose closed days are not all available: one meaning per answer), and with day_not_closed on the open rows (the free-flow group counts only at a close; the account series' open row the same); never 0 for unknown. The day's on a row or wallet; in the portfolio series' meta.totals the covered (closed) days' sum only when every covered day is available, else null with not_ready (never a partial sum).

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

TAO out of the free balance to the EVM side, in rao: EVM gas pre-charges, 0x800 precompile transfers sent, stake added through the staking precompile, the whole msg.value into a bridge escrow (the LayerZero fee inside it). Served on a closed day whose free-flow figures are available (and on the account series' rows, which copy the portfolio row of the address and day): then every free leg of the row is served together, "0" without one. Null with free_evm_bridge_unavailable_reason not_ready on a closed day whose figures aren't available yet (every closed day of a portfolio window whose closed days are not all available: one meaning per answer), and with day_not_closed on the open rows (the free-flow group counts only at a close; the account series' open row the same); never 0 for unknown. The day's on a row or wallet; in the portfolio series' meta.totals the covered (closed) days' sum only when every covered day is available, else null with not_ready (never a partial sum).

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

Why free_evm_bridge_in_rao / free_evm_bridge_out_rao is null: not_ready (the closed day's free-flow figures aren't available yet: every closed day of a portfolio window whose closed days are not all available), day_not_closed (every open row, on both series; never a closed one). Only ever beside a null in its own field(s); null whenever they are served. not_ready also means the row's free_transfer_* include the EVM crossings. day_not_closed (the open rows only, on both series): the free-flow group (every free leg, free_transfer_*, the bridge legs and their set splits) counts only at a close and is null there. The bridge's set split (free_evm_bridge_inside_set_in_rao / _out_rao, free_evm_bridge_across_set_in_rao / _out_rao) has its own reason, free_evm_bridge_set_split_unavailable_reason. New values may be added; treat unknown values as unavailable.

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

TAO from the free balance into stake, in rao: stake, limit and basket transfers to a subnet account, a registration's collateral stake, pre-dTAO add_stake withdrawals. Staking through the EVM precompile is in free_evm_bridge_out_rao. Internal to the total value (free to stake). Served on a closed day whose free-flow figures are available (and on the account series' rows, which copy the portfolio row of the address and day): then every free leg of the row is served together, "0" without one. Null with free_stake_unavailable_reason not_ready on a closed day whose figures aren't available yet (every closed day of a portfolio window whose closed days are not all available: one meaning per answer), and with day_not_closed on the open rows (the free-flow group counts only at a close; the account series' open row the same); never 0 for unknown. The day's on a row or wallet; in the portfolio series' meta.totals the covered (closed) days' sum only when every covered day is available, else null with not_ready (never a partial sum).

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

TAO into the free balance out of stake, in rao: unstake proceeds, pre-dTAO remove_stake deposits and the stake returned on deregistration. Unstaking through the EVM precompile is in free_evm_bridge_in_rao. Internal to the total value (stake to free). Served on a closed day whose free-flow figures are available (and on the account series' rows, which copy the portfolio row of the address and day): then every free leg of the row is served together, "0" without one. Null with free_stake_unavailable_reason not_ready on a closed day whose figures aren't available yet (every closed day of a portfolio window whose closed days are not all available: one meaning per answer), and with day_not_closed on the open rows (the free-flow group counts only at a close; the account series' open row the same); never 0 for unknown. The day's on a row or wallet; in the portfolio series' meta.totals the covered (closed) days' sum only when every covered day is available, else null with not_ready (never a partial sum).

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

Why free_stake_buy_rao / free_stake_sell_rao is null: not_ready (the closed day's free-flow figures aren't available yet: every closed day of a portfolio window whose closed days are not all available), day_not_closed (every open row, on both series; never a closed one). Only ever beside a null in its own field(s); null whenever they are served. New values may be added; treat unknown values as unavailable.

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

Any other TAO into the free balance, in rao: subnet lock refunds, dissolution payouts, crowdloan refunds and payouts, coldkey-swap moves, the block author's fee share, Swap LP principal and fees, the genesis balance, pre-dTAO subnet-owner emission, 0x80a / 0x80b precompile moves. Served on a closed day whose free-flow figures are available (and on the account series' rows, which copy the portfolio row of the address and day): then every free leg of the row is served together, "0" without one. Null with free_other_unavailable_reason not_ready on a closed day whose figures aren't available yet (every closed day of a portfolio window whose closed days are not all available: one meaning per answer), and with day_not_closed on the open rows (the free-flow group counts only at a close; the account series' open row the same); never 0 for unknown. The day's on a row or wallet; in the portfolio series' meta.totals the covered (closed) days' sum only when every covered day is available, else null with not_ready (never a partial sum).

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

Any other TAO out of the free balance, in rao: subnet locks, crowdloan contributions, coldkey-swap moves and costs, Swap LP principal, contract storage deposits, dust lost, 0x80a / 0x80b precompile moves. Served on a closed day whose free-flow figures are available (and on the account series' rows, which copy the portfolio row of the address and day): then every free leg of the row is served together, "0" without one. Null with free_other_unavailable_reason not_ready on a closed day whose figures aren't available yet (every closed day of a portfolio window whose closed days are not all available: one meaning per answer), and with day_not_closed on the open rows (the free-flow group counts only at a close; the account series' open row the same); never 0 for unknown. The day's on a row or wallet; in the portfolio series' meta.totals the covered (closed) days' sum only when every covered day is available, else null with not_ready (never a partial sum).

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

Why free_other_in_rao / free_other_out_rao is null: not_ready (the closed day's free-flow figures aren't available yet: every closed day of a portfolio window whose closed days are not all available), day_not_closed (every open row, on both series; never a closed one). Only ever beside a null in its own field(s); null whenever they are served. New values may be added; treat unknown values as unavailable.

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

The residual: the day's change in free + reserved (System.Account at the day's last block against the previous day's) minus every leg above, the transfers and fee_tx_tao_rao (the transaction fees paid from free), in rao, signed; "0" when the decomposition is complete. Checked every night. Served on a closed day whose free-flow figures are available (and on the account series' rows, which copy the portfolio row of the address and day): then every free leg of the row is served together, "0" without one. Null with free_unexplained_unavailable_reason not_ready on a closed day whose figures aren't available yet (every closed day of a portfolio window whose closed days are not all available: one meaning per answer), and with day_not_closed on the open rows (the free-flow group counts only at a close; the account series' open row the same); never 0 for unknown. The day's on a row or wallet; in the portfolio series' meta.totals the covered (closed) days' sum only when every covered day is available, else null with not_ready (never a partial sum).

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

Why free_unexplained_rao is null: not_ready (the closed day's free-flow figures aren't available yet: every closed day of a portfolio window whose closed days are not all available), day_not_closed (every open row, on both series; never a closed one). Only ever beside a null in its own field(s); null whenever they are served. New values may be added; treat unknown values as unavailable.

daystring (date)

The UTC day (YYYY-MM-DD); a closed day's values are at its last block, the open row's at as_of_height.

Format: date, YYYY-MM-DD
day_statusstring

closed: a finished UTC day, at its last block. open: today, unfinished (see the open row below). The OPEN row is today, unfinished: the last row, served when the window reaches today (on the portfolio series only for 50 accounts or fewer). Its day is meta.to_day + 1 (meta.to_day stays the last closed day), and every value on it is read at as_of_height, the newest block both the chain state and the share flows cover: the balances, stake and total, the net flow and fee since the close, stake_prev_spot_tao_rao (the last close's stake), value_usd, tao_usd, since_close_return_ratio and the transfers since the close (null on the open rows with the rest of the free-flow group, day_not_closed). wallets, subnets, holds_root_stake, the basket and root-accrual legs and every earnings, return and P&L field are null on it, and it is in no total: never read it as a finished day. New values may be added; show an unknown value as is (or generically).

as_of_heightinteger · unit block · can be null

The block every value on the row is read at: a closed day's last block (day_end_height, the UTC day's last block, on both series), the open row's newest block both the chain state and the share flows cover.

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

Free TAO balance at the day's end, in rao.

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

Reserved TAO balance at the day's end, in rao.

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

Sum over the day's positions of alpha x the subnet's closing price, in rao of TAO: a spot valuation, not an exit value. Null when subnets_unpriced > 0 (never a partial sum: the total carries the priced part, flagged total_is_lower_bound). Basis: always the close price (spot), whatever meta.valuation_standard says.

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

The root stake (subnet 0) at the day's close, in rao of TAO (root alpha is TAO, so no price applies). Part of stake_spot_tao_rao, never more than it. 0 when the account held no root stake. Never null on a closed day; null on the open row (root_spot_unavailable_reason).

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

root_spot_tao_rao in USD at that day's tao_usd (an amount), 6 decimals. Null when either is null.

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

Why root_spot_tao_rao is null: day_not_closed on the open row (the subnet split is stated at the close only). Null when the root stake is stated. New values may be added; treat unknown values as unavailable.

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

Pool growth: the rise in value per unit of the validator pools the account holds, as rewards accrue to them (nominator dividends), valued at the day's close, in rao of TAO, signed. Excludes price moves. Staking rewards = stake_income_incl_accrued_tao_rao + stake_growth_tao_rao. Null when a pool the account holds cannot be valued at the close (missing chain data; on an older answer also an L3 pool, fv_reason thin_pool), and on an older data version's answer.

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

Why stake_growth_tao_rao is null: too_many_addresses (more addresses than the closing day's cap), emission_pending (today's open row while the emission data trails), incomplete_data (any other missing input: an unpriced subnet holding growth, the live inputs trailing, or the first closed day without a previous close). Null exactly when stake_growth_tao_rao is served. The figures derived from the growth (stake_other_tao_rao, stake_price_effect_tao_rao, stake_pnl_tao_rao and the returns) are null because it is and carry no reason of their own. Null on an older data version's answer. New values may be added; treat unknown values as unavailable.

positionsinteger · unit count · can be null

Number of stake positions at the day's end. Never null on a closed day; the open row may leave it null.

subnets_unpricedinteger · unit count · can be null

How many subnets the account held stake in had no closing price that day. When above 0, stake_spot_tao_rao is null and total_spot_tao_rao leaves those positions out (total_is_lower_bound). Counts subnets, not positions (/accounts/{address} counts positions). Never null on a closed day; the open row may leave it null.

basket_entitlement_missingboolean · can be null

True on a day the account held root stake but its basket entitlement is not available for that day (basket_entitlement_spot_tao_rao null). Never affects the total. Never null on a closed day; the open row may leave it null.

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

SETTLED value: free + reserved + the priced positions at the day's close, in rao. Never null on a closed day: a lower bound when total_is_lower_bound (an unpriced subnet's positions are left out). The open row may leave it null; when given it is free + reserved + stake as of as_of_height. The basket entitlement is never in it (unrealized: a claim costs fees and has a threshold); it is its own series, basket_entitlement_spot_tao_rao. On the LP days (2025-07-08 to 2026-01-05) it also includes lp_position_cost_tao_rao (the open liquidity positions at cost), so it equals the portfolio series' total for the same account and day; while the cost is not available (null with not_ready) the total is without it. The LP part is at mark when available (lp_position_basis mark), else at cost (cost), else 0 (total_is_lower_bound true). Basis: always the close price (spot), whatever meta.valuation_standard says.

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

The account's open Swap liquidity-provider positions carried at COST, in rao of TAO (the portfolio series' value for the same account and day): the deposited TAO plus the deposited alpha at the pool price of the deposit block, never re-priced (not a market value), constant until a withdrawal. "0" with no open position and on the open row. On the LP days (2025-07-08 to 2026-01-05) it is inside total_spot_tao_rao and total_spot_usd. Null with lp_position_cost_unavailable_reason.

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

Why lp_position_cost_tao_rao is null: not_ready (the LP positions are not available yet; the total is then without them), deposit_price_unknown (a deposit block has no pool price). Only beside a null cost. Null otherwise. When the cost is not known on an LP-era day, total_is_lower_bound may be true (the positions are missing from the total). New values may be added; treat unknown values as unavailable.

basket_entitlement_unavailable_reasonstring · can be null

Why basket_entitlement_spot_tao_rao is null (the portfolio series' reason for the same account and day): not_ready, unpriced or day_not_closed. The entitlement is "0" when nothing is owed, so a null always carries a reason. New values may be added; treat unknown values as unavailable.

total_is_lower_boundboolean · can be null

True when total_spot_tao_rao is a lower bound: a subnet was unpriced that day (subnets_unpriced > 0; the total omits its positions, and stake_spot_tao_rao is null), or an LP-era day (2025-07-08 to 2026-01-05) whose lp_position_cost_tao_rao is not known (null with its reason): the open liquidity positions at cost are missing from the total. It applies to total_spot_usd and to this API's total_incl_unclaimed_spot_tao_rao / _usd too (computed from the total). Never null on a closed day; the open row may leave it null. It is true ONLY when a leg is genuinely missing and counted 0: an address that held an LP position that day whose LP counts 0 (neither mark nor cost available, or the LP kept at 0 while the mark is served for information); LP at cost or at mark is not a lower bound. A wallet that held no LP position is never flagged for it; a day row's flag is its wallets' OR.

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

The day's UNREALIZED basket entitlement, rao: the units the root validators' basket funds owe the account at the day end x each fund's spot NAV per unit then. Its own series, never included in total_spot_*. Null when none is owed or the day is not available (basket_entitlement_missing). Basis: always the close price (spot), whatever meta.valuation_standard says.

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

The account's root earnings on the accrual basis that day, rao: the basket units its validators' funds newly owe it, at the realizable NAV. UNREALIZED until claimed: its own field, never included in total_spot_*. The same meaning as the portfolio series' field of this name, in every root-dividend era: "0" on a known day with nothing owed (and in the in_stake era, where the dividends are inside the stake earnings), the root claimable newly accrued in the root_claimable era. Null only on the first computed day, when a fund or that day's accrual is unpriced or not yet available (unknown, never 0).

Format: whole number, as a string · on chain: u64
tao_usdstring · unit usd_per_tao · can be null

TAO/USD at the day's close (USD per 1 TAO, a price). Null when no price exists for that minute.

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

total_spot_tao_rao in USD at that day's tao_usd (an amount), 6 decimals. Null exactly when tao_usd is (and on the open row when its total is null). It includes the LP positions at cost on the LP days, as the total does. Basis: always the close price (spot), whatever meta.valuation_standard says.

Format: decimal number, as a string
total_incl_unclaimed_spot_tao_raostring · unit rao (÷1e9) · can be null

Total including unclaimed root rewards (basket_entitlement_spot_tao_rao): not yet claimed and not liquid until claimed; the plain total excludes them. total_spot_tao_rao + basket_entitlement_spot_tao_rao, in rao. A null entitlement counts 0 only when basket_entitlement_missing is false (none owed); null when it is true or null, and always on the open row (which never carries the entitlement). A lower bound whenever total_is_lower_bound is true (it is computed from that total). Null when either part is null (an unknown unclaimed amount never counts as 0); equal to total_spot_tao_rao when basket_entitlement_spot_tao_rao is 0. Computed by this API from the served fields.

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

Total including unclaimed root rewards (basket_entitlement_spot_tao_rao): not yet claimed and not liquid until claimed; the plain total excludes them. total_incl_unclaimed_spot_tao_rao in USD at that day's tao_usd, the price total_spot_usd uses (6 decimals, half away from zero). Null when either is null; equal to total_spot_usd when basket_entitlement_spot_tao_rao is 0. Computed by this API.

Format: decimal number, as a string
value_usdstring · unit usd · can be null

The stake (stake_spot_tao_rao) in USD at the row's TAO/USD: the day's close, the open row's as_of_height. Null when either is. Basis: always the close price (spot): stake_spot_tao_rao x the day's TAO/USD rate, whatever meta.valuation_standard says; it is not the base of any return.

Format: decimal number, as a string · can be negative
stake_return_ratiostring · unit ratio · can be null

The stake's return that day (the portfolio series' stake_return_ratio for this one account): (growth + fee + price effect) / the previous close's stake, net of fees; minted income is income, never return. Null on the first computed day, when the previous close holds no stake, or on the open row. Null when the day's income is not known (income_unavailable_reason) or its earnings are not, since the price effect is what remains after income. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

Format: decimal number, as a string · can be negative
stake_return_usd_ratiostring · unit ratio · can be null

The day's return in USD on the day-close basis (meta.usd_basis): (1 + stake_return_ratio) x tao_usd / the previous close's tao_usd - 1. Flows and income are at the close, as in the TAO series. Null when the TAO return or either TAO/USD close is, or on the open row. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

Format: decimal number, as a string · can be negative
since_close_return_ratiostring · unit ratio · can be null

The open row only (null on every closed row): (the stake now - the last close's stake - the stake flows since) / the last close's stake, a ratio; the fees paid since are a cost, in it. Unfinished, in no total. Basis: always the close price (spot), whatever meta.valuation_standard says: the day so far, its flows priced at their own blocks.

Format: decimal number, as a string · can be negative
free_transfer_in_raostring · unit rao (÷1e9) · can be null

TAO received by transfer that day (the open row: since the last close), in rao. Ordinary Balances.Transfer only: a module account's side (stake mechanics) is not a transfer; EVM mirror-to-mirror value transfers are always included. Two meanings, told apart by the row's free_evm_bridge_unavailable_reason. Null (a closed day whose free-flow figures are available, and the account series' rows copied from it): transfers with an ordinary account only; the EVM crossings (0x800 balance-transfer precompile transfers, bridge-escrow deposits and releases, mirror-to-SS58 dispatches) are in free_evm_bridge_in_rao / free_evm_bridge_out_rao instead. not_ready (every closed day of a portfolio window whose closed days' free-flow figures are not all available yet: one meaning per answer): every ordinary transfer, EVM crossings included. day_not_closed (the open rows, on both series): null, the transfers count only at a close (close_only_unavailable_reason day_not_closed on the portfolio row). Null otherwise only on the first computed day (no previous close); "0" / 0 on a later day without transfers.

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

TAO sent by transfer that day (the open row: since the last close), in rao. Ordinary Balances.Transfer only: a module account's side (stake mechanics) is not a transfer; EVM mirror-to-mirror value transfers are always included. Two meanings, told apart by the row's free_evm_bridge_unavailable_reason. Null (a closed day whose free-flow figures are available, and the account series' rows copied from it): transfers with an ordinary account only; the EVM crossings (0x800 balance-transfer precompile transfers, bridge-escrow deposits and releases, mirror-to-SS58 dispatches) are in free_evm_bridge_in_rao / free_evm_bridge_out_rao instead. not_ready (every closed day of a portfolio window whose closed days' free-flow figures are not all available yet: one meaning per answer): every ordinary transfer, EVM crossings included. day_not_closed (the open rows, on both series): null, the transfers count only at a close (close_only_unavailable_reason day_not_closed on the portfolio row). Null otherwise only on the first computed day (no previous close); "0" / 0 on a later day without transfers.

Format: whole number, as a string · on chain: u64
free_transfer_countinteger · unit count · can be null

Transfers in + out that day (the open row: since the last close). Ordinary Balances.Transfer only: a module account's side (stake mechanics) is not a transfer; EVM mirror-to-mirror value transfers are always included. Two meanings, told apart by the row's free_evm_bridge_unavailable_reason. Null (a closed day whose free-flow figures are available, and the account series' rows copied from it): transfers with an ordinary account only; the EVM crossings (0x800 balance-transfer precompile transfers, bridge-escrow deposits and releases, mirror-to-SS58 dispatches) are in free_evm_bridge_in_rao / free_evm_bridge_out_rao instead. not_ready (every closed day of a portfolio window whose closed days' free-flow figures are not all available yet: one meaning per answer): every ordinary transfer, EVM crossings included. day_not_closed (the open rows, on both series): null, the transfers count only at a close (close_only_unavailable_reason day_not_closed on the portfolio row). Null otherwise only on the first computed day (no previous close); "0" / 0 on a later day without transfers.

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

Transaction fees the account paid in TAO that day, as a positive amount paid (unsigned), in rao (the portfolio series' fee_tx_tao_rao for this one account): the fees of the extrinsics it paid for (as the signer, or as a proxy's real account; the tip included), without the fees the chain took in alpha (those are fee_tx_alpha_tao_rao). A cost of the free balance, outside stake: in no stake figure. On the open row: today so far, as of as_of_height, by the same rules (alpha at that block's price); null with fee_unavailable_reason too_many_rows when the account paid over 200 transaction fees since the last close. Null on the series' first day and on a day whose account-day figures aren't available.

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

Transaction fees the account paid in alpha that day, each subnet's alpha at its closing price, in rao of TAO, as a positive amount paid (the portfolio series' fee_tx_alpha_tao_rao, its stake_fee_tao_rao negated, for this one account). Negative only when a fee refunded after dispatch exceeded that day's fees. Already inside the stake and stake_return_ratio: never add it again. On the open row: today so far, as of as_of_height, by the same rules (alpha at that block's price); null with fee_unavailable_reason too_many_rows when the account paid over 200 transaction fees since the last close. Null where the portfolio series' stake_fee_tao_rao is null. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

Format: whole number, as a string · can be negative
fee_swap_tao_raostring · unit rao (÷1e9) · can be null

The pool's swap fees on the trades the account paid for that day (buy, sell and both legs of a swap, charged to the payer: the account whose stake is sold; a stake transfer's recipient gets the net and is charged nothing), as a positive amount paid (unsigned), in rao of TAO (the portfolio series' fee_swap_tao_rao for this one account): TAO fees as charged, alpha fees at the day's closing price. Informational: the fee is already inside the flow (the alpha received or the TAO paid out is net of it), so never add it again. Pool steps without a stake event (claims, registrations, fund swaps) state no fee and are left out. On the open row: today so far, as of as_of_height, by the same rules (alpha at that block's price); null with fee_unavailable_reason too_many_rows when the account paid over 200 transaction fees since the last close. Null when a trade's event carries no fee (dTAO trades before runtime spec 256, blocks 4,920,351 to 5,228,683) and on a day whose trade figures aren't available yet. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

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

fee_tx_tao_rao + fee_tx_alpha_tao_rao + fee_swap_tao_rao, in rao of TAO, as a positive amount paid (the portfolio series' fee_total_tao_rao for this one account; negative only through a refunded alpha fee). Informational: every part is already inside the flows or the stake. Null when any part is. Basis: fair value (the valuation standard's revision rev5 or later, meta.valuation_standard): each subnet's alpha at its per-unit fair value at the day's close (the close price on a deep pool, the price a small reference sale would get on a thin one; flows and fees at the same per-unit value). A pool that moves between depth levels from one close to the next shows as a price effect. Two disclosed departures: a liquidity position's alpha leg stays at the close mark, and a dissolved subnet life's position keeps the prices of its own movements.

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

Why the row's fee_total_tao_rao (and its parts) is null, on closed and open rows alike (the portfolio series' fee_unavailable_reason for this one account). Only ever set beside a null fee_total_tao_rao. too_many_rows: the account paid more than 200 transaction fees since the last close (a validator owner's weight upkeep: about 3,000 a day), past the open row's read budget; the closed row serves the day's fees. too_many_addresses: the portfolio series' code for an address set over its open-day cap, kept in the shared list. The four fees are null beside either. fee_not_stated_by_chain: a trade that day carries no fee on chain (dTAO trades before runtime spec 256), so fee_swap_tao_rao is null. incomplete_data: any other null (a part not known: the series' first day, a day that isn't available yet, an unpriced alpha fee, a fee with no leg). fee_legs_mismatch: the day's fee legs don't cover the fee alpha the chain states. Null when the total is served, and on a day whose portfolio figures are missing. New values may be added; treat unknown values as unavailable.

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

The stake's earnings that day, in rao of TAO (signed): its alpha change minus the account's own flows, at the day's close (growth + income + fee + other). It equals the portfolio series' stake_earned_tao_rao for the same account and day. Served on closed days; null with earned_unavailable_reason otherwise (always on the open row). Null when an income credit of the day has no price (not_priced): never a partial sum.

Format: whole number, as a string · can be negative
earned_usdstring · unit usd · 6 decimals · can be null

earned_spot_tao_rao in USD at the day's close rate (tao_usd), signed, 6 decimal places. Null when earned_spot_tao_rao is null or the day has no close rate (then with earned_unavailable_reason incomplete_data).

Format: decimal number, as a string · can be negative
earned_unavailable_reasonstring · can be null

Why earned_spot_tao_rao or earned_usd is null that day; null exactly when both are served. day_not_closed: the open row (earnings are stated for closed days only). no_previous_close: the account's first computed day, which has no previous close to measure from. incomplete_data: a value or price that day is unknown, or the day has no close rate (then earned_spot_tao_rao is served and only earned_usd is null). thin_pool (an older answer only; a current answer values L3 pools): a stake position is on an L3 pool at the day's close (fv_level_worst), so the day's earnings have no fair value. not_priced: an income credit of the day has no price, so the earnings are not stated (never a partial sum). Clients must accept codes not listed here. New values may be added; treat unknown values as unavailable.

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

The stake at fair value, in rao of TAO (the portfolio series' stake_fair_value_tao_rao for this one account): each held subnet position valued at its pool's fair-value level at the day's close (L1: its spot value; L2: the alpha at the 10-alpha reference-sale price; L3: a measured Level 3 value (each subnet row's fv_method): the price a 10-alpha sale would get from the pool's reserves (reference_sale; from the TAO reserve alone when the alpha reserve is 0), 0 when the pool holds no TAO (no_tao), or, at an instant with neither reserve during the subnet's dissolution, the dissolution payout (dissolution); floored per position), summed. stake_spot_tao_rao is unchanged beside it. Null, never a partial sum, when a held position has no price or level (unpriced, reserves_unknown), and on an older answer also when one is on an L3 pool (fv_reason thin_pool). Levels, by the pool at the day's close: L1 (at least 1,000 alpha in the pool's reserve) values alpha at the pool price, so an L1 figure is the spot figure; L2 (at least 1 alpha in reserve) at the price a 10-alpha sale would get, fees excluded; L3 (less than 1 alpha in reserve) at a measured Level 3 value (each subnet row's fv_method): the price a 10-alpha sale would get from the pool's reserves (reference_sale; from the TAO reserve alone when the alpha reserve is 0), 0 when the pool holds no TAO (no_tao), or, at an instant with neither reserve during the subnet's dissolution, the dissolution payout (dissolution). Root is L1. An older answer (its fv_level_mix carries value_l3_or_unpriced_spot_tao_rao, not value_l3_tao_rao) gives L3 no fair value (thin_pool); a current answer values L3 and never says thin_pool.

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

The worst fair-value level (L1 best, L3 worst) among the account's stake positions that day (held, moved or credited). Null when there is none, or none has a price. Levels, by the pool at the day's close: L1 (at least 1,000 alpha in the pool's reserve) values alpha at the pool price, so an L1 figure is the spot figure; L2 (at least 1 alpha in reserve) at the price a 10-alpha sale would get, fees excluded; L3 (less than 1 alpha in reserve) at a measured Level 3 value (each subnet row's fv_method): the price a 10-alpha sale would get from the pool's reserves (reference_sale; from the TAO reserve alone when the alpha reserve is 0), 0 when the pool holds no TAO (no_tao), or, at an instant with neither reserve during the subnet's dissolution, the dissolution payout (dissolution). Root is L1. An older answer (its fv_level_mix carries value_l3_or_unpriced_spot_tao_rao, not value_l3_tao_rao) gives L3 no fair value (thin_pool); a current answer values L3 and never says thin_pool. New values may be added; show an unknown value as is (or generically).

fv_level_mixobject · can be null

The held positions by fair-value level: value_l1_tao_rao + value_l2_tao_rao + value_l3_tao_rao = stake_fair_value_tao_rao whenever that is served, and value_unpriced_spot_tao_rao holds the unpriced rest at spot. On an older answer value_l1_tao_rao + value_l2_tao_rao = the fair value and value_l3_or_unpriced_spot_tao_rao holds the rest at spot. Null only on an open row over the address cap.

6 fields in fv_level_mix
value_l1_tao_raostring · unit rao (÷1e9)

Positions on an L1 pool, at fair value (= their spot value), in rao of TAO.

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

Positions on an L2 pool, at fair value (the alpha at the 10-alpha reference-sale price, floored per position), in rao of TAO.

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

An older answer's bucket: positions with no fair value there (an L3 pool, or no level), at SPOT, in rao of TAO: the part stake_fair_value_tao_rao cannot hold, never added to it. Null on a current answer, which splits it into value_l3_tao_rao and value_unpriced_spot_tao_rao.

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

Positions on an L3 pool, at fair value (a measured Level 3 value (each subnet row's fv_method): the price a 10-alpha sale would get from the pool's reserves (reference_sale; from the TAO reserve alone when the alpha reserve is 0), 0 when the pool holds no TAO (no_tao), or, at an instant with neither reserve during the subnet's dissolution, the dissolution payout (dissolution); floored per position), in rao of TAO: part of stake_fair_value_tao_rao. Null on an older answer (value_l3_or_unpriced_spot_tao_rao).

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

Positions with no fair value (missing chain data: no price or no level), at SPOT, in rao of TAO: the part stake_fair_value_tao_rao cannot hold, never added to it; while it is above 0 the fair value is null. Null on an older answer (value_l3_or_unpriced_spot_tao_rao).

Format: whole number, as a string · on chain: u64
unpriced_countinteger · unit count

Held positions with no price at all (valued in none of the other buckets).

fv_reasonstring · can be null

Why a fair-value figure is null; null when nothing is withheld for valuation. unpriced / reserves_unknown: only stake_fair_value_tao_rao is null (missing chain data; on a current answer the only cause, unpriced). too_many_addresses: an open row over the address cap. thin_pool (an older answer only; a current answer values L3 pools): a stake position is on an L3 pool at the day's close (earned_spot_tao_rao, earned_usd and stake_fair_value_tao_rao are null), or the previous close held one (the day's return is not measurable at fair value; the earnings are served). An open vocabulary: clients must accept a value not listed here and show it as it is. New values may be added; treat unknown values as unavailable.

hotkeyobject · can be null

Only with include=hotkey (absent otherwise): the address as a hotkey, exactly the data GET /hotkeys/{address}?include=subnets answers (owner, take, stake and, per subnet, its UID, validator permit and emission). Null when the chain never stored it as a hotkey (meta.sections.hotkey.unavailable_reason not_a_hotkey) or when the read is unavailable (another reason). Head only: with an at the request is a 400 INCLUDE_AT_HEAD_ONLY, and an answer carrying it is cached like a head answer (tip).

30 fields in hotkey
hotkeyobject

The hotkey, as {ss58, hex}.

2 fields in hotkey
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
identityobject · can be null

The hotkey's on-chain identity, else its Owner coldkey's (identity_via_owner). Null when neither has one, and on an older data version's answer.

9 fields in identity
namestring · can be null

The display name. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

urlstring · can be null

The website. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

github_repostring · can be null

The GitHub repository. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

imagestring · can be null

The identity's image: our copy of the image (fetched, checked and re-encoded by bittensor.ai), never the URL set on chain. Null when we hold no copy: image_unavailable_reason says why.

discordstring · can be null

The Discord handle. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

descriptionstring · can be null

A free-text description. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

additionalstring · can be null

Any additional text. As the owner set it (UTF-8; "" when left empty); null when the stored bytes are not valid UTF-8 (decoded false).

image_unavailable_reasonstring · can be null

Why image is null: none_set (no image is set on chain), not_mirrored_yet (one is set and we hold no copy of it yet), fetch_failed (our last fetch of it failed: not found, refused, unreachable, or not a usable https URL) or unsafe_content (what it points at was refused: not an allowed image type, invalid or too large). Null exactly when image is served. New values may be added; treat unknown values as unavailable.

decodedboolean

True when every stored field is valid UTF-8; false when one is not (that field is then null).

identity_via_ownerboolean · can be null

True when identity is the Owner coldkey's (the hotkey has none of its own). Null on an older data version's answer.

root_uidinteger · unit id · can be null

Its UID on root (netuid 0). Null when not registered on root, and on an older data version's answer.

subnet_countinteger · unit count · can be null

Subnets it holds a UID on, root included. Null on an older data version's answer.

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

Its stake on every subnet (TotalHotkeyAlpha) valued at each subnet's spot price, root 1:1, in rao of TAO. Null on an older data version's answer.

Format: whole number, as a string · can be negative
own_stake_spot_tao_raostring · unit rao (÷1e9) · can be null

The Owner coldkey's own positions on the hotkey (self-bonded), sized as /accounts/positions, in rao of TAO at spot. Null on an older data version's answer.

Format: whole number, as a string · can be negative
nominator_positionsinteger · unit count · can be null

Coldkeys holding a share, summed over its pools (a coldkey in several pools counts in each). Null on an older data version's answer.

emission_30dobject · can be null

The last 30 closed UTC days' emission through it. Null on an older data version's answer.

11 fields in emission_30d
from_daystring (date) · can be null

First UTC day of the window, inclusive: the window's first AVAILABLE day (later than to_day - 29 when fewer days are available, days_available). Null while no day is available.

Format: date, YYYY-MM-DD
to_daystring (date) · can be null

Last UTC day, inclusive: meta.emission_last_day, the last available day. Null while none is.

Format: date, YYYY-MM-DD
days_availableinteger · unit count · can be null

The UTC days in to_day - 29 .. to_day with emission rows available (0..30). Null on an older data version's answer.

days_builtinteger · unit count · can be null · deprecated

The UTC days in to_day - 29 .. to_day with emission rows available (0..30). Null on an older data version's answer. Deprecated: use days_available; sunset 2027-02-15.

Deprecated since 2026-10-17, removed after 2027-02-15. Use days_available instead.
total_spot_tao_raostring · unit rao (÷1e9) · can be null

Realized credits only: pool_dividend + take + miner_incentive + owner_cut, in rao of TAO at each subnet's spot price now (root 1:1). The root claimable is never in it (accrued until claimed: root_claimable_spot_tao_rao), and basket flush credits are in no member. The sort=emission_30d key. On an older data version's answer: every component (pool_dividend + take + miner_incentive + other). Null when not known (a credit's subnet with no spot price now, e.g. dissolved since).

Format: whole number, as a string · can be negative
pool_dividend_spot_tao_raostring · unit rao (÷1e9) · can be null

The pool's dividends (nominator_dividend): paid to the nominators, the owner's own stake included. They grow the stakers' positions: not the operator's income. Null when not known (a credit's subnet with no spot price now, e.g. dissolved since).

Format: whole number, as a string · can be negative
take_spot_tao_raostring · unit rao (÷1e9) · can be null

The take: validator_take + root_take (validator_take alone on an older data version's answer). Null when not known (a credit's subnet with no spot price now, e.g. dissolved since).

Format: whole number, as a string · can be negative
miner_incentive_spot_tao_raostring · unit rao (÷1e9) · can be null

Miner incentive credited to the hotkey (miner_incentive). Null when not known (a credit's subnet with no spot price now, e.g. dissolved since).

Format: whole number, as a string · can be negative
owner_cut_spot_tao_raostring · unit rao (÷1e9) · can be null

The subnet owner's cut credited to this hotkey (owner_cut), part of the total. Null on an older data version's answer (where it was inside other_spot_tao_rao).

Format: whole number, as a string · can be negative
root_claimable_spot_tao_raostring · unit rao (÷1e9) · can be null

Root dividends queued for the root stakers to claim (root_claimable_queued), at spot. Accrued, not realized: never part of total_spot_tao_rao or any amount total. Null on an older data version's answer.

Format: whole number, as a string · can be negative
other_spot_tao_raostring · unit rao (÷1e9) · can be null · deprecated

Deprecated. An older data version's every other component (root claimable, root take, owner cut, basket flush credits, ...), summed into its total. Null on every current answer, which splits it: the owner cut (owner_cut_spot_tao_rao, in the total), the root take (in take_spot_tao_rao) and the root claimable (root_claimable_spot_tao_rao, never in the total). Served as before on an older data version's answer. Deprecated: use owner_cut_spot_tao_rao / root_claimable_spot_tao_rao; sunset 2027-02-15.

Format: whole number, as a string · can be negative
Deprecated since 2026-10-04, removed after 2027-02-15. Use owner_cut_spot_tao_rao / root_claimable_spot_tao_rao instead.
stakingobject · can be null

For a fund validator, the staking figures as /baskets rows serve them (APY at the reference stake, realised nominator APY, swap costs, breakeven): the top-level figures over every pool, root included; subnet_only over the subnet pools only (netuid != 0; null on an older data version's answer). Null for other hotkeys, and on an older data version's answer.

13 fields in staking
poolsinteger · unit count · can be null

The validator's staked pools blended: every pool, root included (subnets and root).

pools_refusedinteger · unit count · can be null

Pools whose per-share return was refused (a share restart, or no history).

window_daysobject

The pools' window lengths.

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

The day's reference stake, rao (the 30-day median real stake-add; 10 TAO fallback): what the reference figures and the costs are for. Null before the first reference day.

Format: decimal number, as a string · can be negative
nominator_apy_ratiostring · unit ratio · 8 decimals · can be null

Σ w ((1 + y)^(365 / days) - 1) / Σ w: y = the pool's per-share return (TotalHotkeyAlpha / shares) over its window, net of the validator's take, alpha-denominated (the price move is not included); w = the pool's TAO value at its window open. The ROOT pool's y is its accrued root claimable over meta.root_yield_window against its root stake at the window open (pool-wide, net of take, at spot, before a claim's swap cost and RootClaimableThreshold): accrued, not realised. A rate, never a stake or income total. A signed ratio, 8 decimals. Null when a pool is refused (or none).

Format: decimal number, as a string · can be negative
apy_at_reference_stake_ratiostring · unit ratio · 8 decimals · can be null

The same on y x M: the APY a new stake of reference_stake_tao_rao would earn, with M the dilution of the reference stake X joining the pool (root: A / (A + X); a subnet: T/(T+X) x (s+X+K)/(s+K) x (A+R)/(A+X+R)). A constant-dividend model, the dividend held constant when X joins, so it understates under Yuma, where the dividend grows with stake. 8 decimals. Null with unavailable_reason (refused, no reference stake, an unpriced pool).

Format: decimal number, as a string · can be negative
reference_apr_ratiostring · unit ratio · 8 decimals · can be null

Σ w (y M x 365 / days) / Σ w: the simple (uncompounded) APR at the reference stake, breakeven_days' rate. 8 decimals. Null as apy_at_reference_stake_ratio.

Format: decimal number, as a string · can be negative
round_trip_cost_ratiostring · unit ratio · 8 decimals · can be null

1 - TAO back / the reference TAO, blended over the pools: the runtime's swap simulation at the day-end block (buy, then sell the alpha back against the same pool state); root 0. 8 decimals. Null while a pool's simulation is pending, or without a reference stake.

Format: decimal number, as a string · can be negative
entry_cost_ratiostring · unit ratio · 8 decimals · can be null

1 - alpha out x spot / the reference TAO, blended; root 0. 8 decimals. Null as round_trip_cost_ratio.

Format: decimal number, as a string · can be negative
exit_cost_ratiostring · unit ratio · 8 decimals · can be null

1 - TAO back / (alpha out x spot), blended; root 0. 8 decimals. Null as round_trip_cost_ratio.

Format: decimal number, as a string · can be negative
breakeven_daysstring · unit days · 2 decimals · can be null

round_trip_cost_ratio / (reference_apr_ratio / 365): the days the reference stake must stay to earn back its round trip, dividing exactly the cost served beside it by the APR served beside it (2 decimals). Null when either is, or when the served APR is not above 0 (unavailable_reason no_yield).

Format: decimal number, as a string · can be negative
unavailable_reasonstring · can be null

Why figures are null (precedence in this order): no_pools (no staked pool), pool_refused (a pool's return was refused: every APY and APR null), parent_set_unknown (a staked pool carries material childkey take, so its yield is rated over 1 day only until its per-day parent sets are stored) and window_too_short (a staked pool's yield window is shorter than its full window, 7 days or root's 30: a younger pool), either nulling every APY, the APR and the breakeven while the costs stay when known (parent_set_unknown is served when both hold), no_reference_stake (the reference figures and the costs null), pool_unpriced (a pool has no spot price: the reference APY, APR and breakeven null; nominator_apy_ratio stands), not_ready (the day's stake weights are not available yet: as pool_unpriced), swap_cost_pending (a pool's swap simulation has not run: the costs and breakeven null) or no_yield (the served reference_apr_ratio is not above 0, so only breakeven_days is null; the APYs, the APR and the costs are given). Null when every figure is given. New values may be added; treat unknown values as unavailable.

subnet_onlyobject · can be null

The same figures over the subnet pools only (netuid != 0; root apart): root's low yield and zero swap cost no longer dilute them. The top-level figures stay the blend over every pool, root included. Null on an older data version's answer.

knownboolean

Whether the chain has ever stored a key for this hotkey (any storage item, at any time). False = never seen: subnets and every other list are [] (GET /hotkeys/{hotkey} answers such a hotkey with a 404 HOTKEY_NOT_FOUND; the list and batch forms keep its item). True with subnets [] = a known hotkey registered nowhere at meta.at.

owner_coldkeystring · can be null

The coldkey that owns the hotkey (SubtensorModule.Owner), SS58. Null without an Owner entry.

Format: SS58 address
take_ratiostring · unit ratio · 6 decimals · can be null

The effective delegate take as a ratio 0..1, 6 decimals: the share of its nominators' dividends the hotkey keeps: its Delegates entry (u16 / 65535), else the runtime's default take (take_is_default true). Never null for a missing Delegates entry on an answer carrying take_is_default; on an older answer null without a Delegates entry (never 0 %).

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

true when the hotkey has no Delegates entry, so take_ratio is the runtime's default take (Delegates' storage default under the head's runtime: DefaultDelegateTake, 0.179995). Null on an answer from before the data source served it.

nominator_walletsinteger · unit count · can be null

Distinct coldkeys holding a non-zero share (Alpha / AlphaV2) in any of its pools, each counted ONCE however many subnets it stakes on (nominator_positions counts per pool). For a validator candidate the directory's count (GET /validators' meta.nominator_wallets_at, refreshed about every 10 minutes), else counted at meta.at. Null on an older answer.

nominator_positions_valuedinteger · unit count · can be null

Nominator positions WORTH AT LEAST 1 RAO at spot (floor(alpha x spot) >= 1; root 1:1), module and escrow (modl...) accounts excluded: the count a staker-facing page shows (nominator_positions is the exact count, dust and module accounts included). Null when not counted yet (a large hotkey is counted on a schedule), and on an older data version's answer.

nominator_wallets_valuedinteger · unit count · can be null

Distinct coldkeys among nominator_positions_valued's positions (nominator_wallets is the exact count). Null exactly when nominator_positions_valued is.

first_seen_heightinteger · unit block · can be null

The block the hotkey's Owner key was first written (its creation: its first registration or association), as far back as the storage index reaches. Null when it has no Owner entry, and on an older answer.

last_seen_heightinteger · unit block · can be null

The newest of LastUpdate (its last weights) and the registration block over its uids now (a slot never updated keeps its previous holder's LastUpdate, so the registration bounds it). Null when it holds no uid, when that block is above meta.at (a stalled chain-state dataset), and on an older answer.

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

Its root stake now, TotalHotkeyAlpha(hotkey, 0) (root is 1:1), rao of TAO. Null on an older data version's answer.

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

Its stake on the subnets (netuid >= 1) valued at each subnet's spot price, rao of TAO; stake_spot_tao_rao = root_stake_tao_rao + this (checked). Null when any staked pool is unpriced (never a partial sum), and on an older answer.

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

The Delegates take now is above its value 216,000 blocks (30 days) back. A chain fact, never a judgement. Null on an older answer.

staking_optionsobject · can be null

Option A (root_stake) and option B (fund, the full block) as two separate blocks, never combined (no rate across options), each with its own as_of_day / as_of_height (stored once per accrual day). Served beside the legacy staking, which a later version removes. Null on an older answer.

3 fields in staking_options
root_stakeobject

Option A: root stake to this validator.

fundobject · can be null

Option B: its fund units, the full block. Null when it runs no fund.

subnetsarray of objects · optional

Only with include=staking_options beside include=subnets (absent otherwise, and on an older data version's answer): option C, one row per pool the hotkey has stake in on a subnet (netuid >= 1), by apy_7d.value descending (nulls last), then the pool at spot (checked). A ranked list of separate pools: never average their rates.

swapsarray of objects · optional

Detail (include=subnets / daily); absent otherwise. Hotkey swaps that made this hotkey the new key, oldest first ([] when none recorded). Read from decoded events, which are contiguous only from meta.swaps_from_height: a swap below it may be missing.

3 fields in swaps (each item)
heightinteger · unit block

Block of the swap event.

old_hotkeystring · can be null

The hotkey swapped out (the previous key), SS58 (prefix 42).

Format: SS58 address
netuidinteger · unit id · can be null

The subnet a per-subnet swap applied to; null for a whole-hotkey swap (on every subnet).

subnetsarray of objects · optional

Detail (include=subnets / daily); absent otherwise. Every subnet the hotkey holds a UID on at meta.at, root included, by netuid ([] when none). A registration in the last few minutes (after the chain-state dataset's head) is not listed yet.

22 fields in subnets (each item)
netuidinteger · unit id

The subnet slot (0 = root).

uidinteger · unit id

The hotkey's UID on the subnet.

activeboolean · can be null

Active[uid]: whether the UID counted as active in the last epoch.

validator_permitboolean · can be null

ValidatorPermit[uid].

stake_alpha_raostring · unit alpha_rao (÷1e9) · can be null

TotalHotkeyAlpha(hotkey, netuid): all alpha staked to the hotkey on the subnet (the owner's and every nominator's), in alpha rao; 0 without stake.

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

floor(stake_alpha_rao x the subnet's spot price at meta.at), in rao of TAO (1:1 on root): a spot valuation, not an exit value. Null without a pool price.

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

stake_spot_tao_rao in USD at meta.tao_usd (6 decimals). Null without either price.

Format: decimal number, as a string
nominatorsinteger · unit count · can be null

Stake positions (coldkeys holding shares) on the hotkey on this subnet, the owner's own included.

childkey_take_ratiostring · unit ratio · 6 decimals · can be null

ChildkeyTake on this subnet / 65535, a ratio with 6 decimals. Null without an entry (a take of 0).

Format: decimal number, as a string
registered_at_heightinteger · unit block · can be null

BlockAtRegistration[uid]: the block the UID was registered at.

immuneboolean · can be null

Whether the UID is still inside the subnet's ImmunityPeriod since registration at meta.at.

immunity_left_blocksinteger · unit blocks · can be null

Blocks of immunity left at meta.at (0 once past ImmunityPeriod).

emission_epoch_alpha_raostring · unit alpha_rao (÷1e9) · can be null

Emission[uid]: the alpha the last epoch paid the UID, in alpha rao. The prune order ranks by it.

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

Incentive[uid] / 65535 (the miner share), 6 decimals.

Format: decimal number, as a string
dividends_ratiostring · unit ratio · 6 decimals · can be null

Dividends[uid] / 65535 (the validator share), 6 decimals.

Format: decimal number, as a string
weightsobject

Weight setting and consensus of the UID.

childrenarray of objects · optional

Only with include=childkeys (absent otherwise, since 2026-10-09: payload size). ChildKeys on this subnet: the hotkeys this one delegates stake weight to ([] when none). The same as the item's childkeys[] entry for this subnet, which also covers subnets without a UID.

parentsarray of objects · optional

Only with include=childkeys (absent otherwise, since 2026-10-09: payload size). ParentKeys on this subnet: the hotkeys delegating stake weight to this one ([] when none). The same as the item's childkeys[] entry for this subnet.

pending_childrenobject · can be null

PendingChildKeys on this subnet: a scheduled new child set and when it applies. Null when none. A set scheduled on a subnet the hotkey holds no UID on is in the item's childkeys[].

stake_weightobject · can be null

The stake weight the subnet's latest epoch used for this UID (as the metagraph's stake_weight_alpha / stake_weight_share): alpha-equivalent stake (alpha + tao_weight x TAO, both inherited through childkeys), filtered only by the global StakeThreshold, not the permit filter. Null when the UID is not in that epoch's vector (registered after it) or the subnet has no epoch in coverage (root), which is distinct from a weight of 0.

nominator_yieldobject

The pool's nominator APYs in alpha.

pruneobject

The UID's place in the runtime's prune order (whom the next registration replaces): by last-epoch Emission on a subnet, by root stake on root (netuid 0, basis root_stake).

dailyarray of objects · can be null

The emission credits through the hotkey per (UTC day, subnet) from meta.from_day to meta.to_day, by day then netuid ([] when none). Only with include=daily: null with include=subnets alone (totals still cover the window), absent without either.

13 fields in daily (each item)
daystring (date)

The UTC day.

Format: date, YYYY-MM-DD
netuidinteger · unit id · can be null

The subnet whose alpha was credited. Null on an aggregated (cross-subnet) row. By default one row per day across the hotkey's subnets (netuid and every alpha member null: alpha of different subnets does not add up; the *_spot_tao_rao members are the sums); daily_netuid gives one subnet's rows instead (this shape per subnet, subnets 1).

by_type_alpha_raoobject · unit alpha_rao (÷1e9) · can be null

The day's credits through the hotkey by type, in alpha rao of netuid: miner_incentive, validator_take, nominator_dividend (paid into the hotkey's pool: its nominators' and owner's stake grows by it; not the operator's income), owner_cut, root_take, root_claimable_queued (a root validator's stakers' dividends on this subnet, queued as claimable) and basket_flush_credit. An open map: only the types credited that day appear, and clients must accept types not documented yet. Null on an aggregated row (by_type_spot_tao_rao there).

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

Aggregated rows: each component of by_type_alpha_rao at its subnet's day-close spot, floored per subnet and summed over the priced subnets, rao of TAO (an open map, as by_type_alpha_rao). root_claimable_spot_tao_rao is its root_claimable_queued (checked). Null when no subnet of the day is priced, on a per-subnet row and on an older answer.

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

The root claimable queued that day at spot (accrued, unrealized: never in an amount total), rao of TAO, summed over the priced subnets on an aggregated row. Null on a per-subnet row whose day is unpriced, and on an older answer.

Format: whole number, as a string · on chain: u64
subnetsinteger · unit count · can be null

The subnets in the row (1 on a per-subnet row, checked). Null on an older answer.

unpriced_subnetsinteger · unit count · can be null

The subnets of the row without a day-close price: their credits are missing from the spot sums (0..subnets; on a per-subnet row 1 exactly when total_spot_tao_rao is null, checked). Null on an older answer.

total_alpha_raostring · unit alpha_rao (÷1e9) · can be null

Every credit the hotkey received that day on the subnet, the sum of by_type_alpha_rao (every component), in alpha rao of netuid: a flow total, never the validator's income (it includes root_claimable_queued, accrued and unrealized, and basket_flush_credit, a re-credit of claimable already counted). The income figure is realized_alpha_rao. Null on an aggregated (cross-subnet) row.

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

total_alpha_rao at the subnet's price at the day's last credit (1:1 on root), in rao of TAO: a flow total, never income (see realized_spot_tao_rao). Null when no pool price is recorded for it (the pool history starts on 2026-09-27). On an aggregated row: the sum over the priced subnets, each floored (never null; unpriced_subnets counts the subnets left out).

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

total_spot_tao_rao at TAO/USD of the day's close (6 decimals). Null without either price.

Format: decimal number, as a string
realized_alpha_raostring · unit alpha_rao (÷1e9) · can be null

The realized credits only, every component except root_claimable_queued (accrued, unrealized) and basket_flush_credit (a re-credit of claimable already counted): the income figure, in alpha rao of netuid. Exactly total_alpha_rao less those two components (checked). Null on an older answer, and on an aggregated row.

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

realized_alpha_rao at the day's close price (1:1 on root), in rao of TAO. Null exactly when total_spot_tao_rao is (an unpriced day), and on an older answer. On an aggregated row the sum over the priced subnets: total_spot_tao_rao less the root claimable and basket flush credits at spot, within the per-subnet floors (checked).

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

The root claimable queued that day (by_type_alpha_rao.root_claimable_queued, 0 when none), in alpha rao of netuid: accrued, unrealized until claimed, never in an amount total. Null on an older answer, and on an aggregated row (root_claimable_spot_tao_rao there).

Format: whole number, as a string · on chain: u64
childkeysarray of objects · optional

Only with include=childkeys beside the detail (include=subnets / daily); absent otherwise (since 2026-10-09: payload size). The hotkey's children, parents and pending child set on every subnet where it has any, whether or not it holds a UID there, by netuid ([] when none). On a subnet with a UID the same as that subnets[] entry's children / parents / pending_children.

4 fields in childkeys (each item)
netuidinteger · unit id

The subnet slot.

childrenarray of objects

ChildKeys: the hotkeys this one delegates stake weight to ([] when none).

parentsarray of objects

ParentKeys: the hotkeys delegating stake weight to this one ([] when none).

pending_childrenobject · can be null

PendingChildKeys: a scheduled new child set and when it applies. Null when none.

childkey_dailyarray of objects · can be null

Only with include=daily: null with include=subnets alone, absent without either. The childkey split per (UTC day, subnet) where the hotkey took part, as a child or as a parent, in amounts actually paid (the runtime's own split lines scaled by each recipient's paid / pre-re-split dividends; Paid amounts can be above or below the split line's own figure, and nothing is taken twice: after the childkey split the runtime splits each hotkey's dividends into an alpha part and a root part by its own stake mix, then rescales each side to its fixed share of validator emission (on SN26 one day: alpha x1.391, root x0.680, the total unchanged), so a hotkey's paid / split ratio can exceed 1: validators staked all in alpha are paid above their split figure, root-heavy ones below.), by day then netuid. A day listed in meta.childkey_missing_days isn't available yet: it has no row, which does not mean zero. On every other day of the window no row means the hotkey had no childkey split that day on that subnet (a real zero).

9 fields in childkey_daily (each item)
daystring (date)

The UTC day.

Format: date, YYYY-MM-DD
netuidinteger · unit id · can be null

The subnet. Null on an aggregated (cross-subnet) row. By default one row per day across the hotkey's subnets (netuid and every alpha member null: alpha of different subnets does not add up; the *_spot_tao_rao members are the sums); daily_netuid gives one subnet's rows instead (this shape per subnet, subnets 1).

take_gained_alpha_raostring · unit alpha_rao (÷1e9) · can be null

Childkey take paid to this hotkey as a child on the subnet: its share, at its childkey take, of the dividends its parents' stake weight earned through it. In alpha rao of the subnet. An amount actually paid: the runtime's split line scaled by the recipient hotkey's paid / pre-re-split dividend ratio (per recipient it equals the emission credits within 10 rao on 5,336 of 5,341 hotkeys; the other 5 are validators without parents that epoch, where only the kept-as-parent share is in the split by definition). Paid amounts can be above or below the split line's own figure, and nothing is taken twice: after the childkey split the runtime splits each hotkey's dividends into an alpha part and a root part by its own stake mix, then rescales each side to its fixed share of validator emission (on SN26 one day: alpha x1.391, root x0.680, the total unchanged), so a hotkey's paid / split ratio can exceed 1: validators staked all in alpha are paid above their split figure, root-heavy ones below. Null on an aggregated (cross-subnet) row.

Format: whole number, as a string
take_paid_alpha_raostring · unit alpha_rao (÷1e9) · can be null

Childkey take paid to this hotkey's children on the subnet out of its share of their dividends (their take on the dividends its stake weight earned through them). In alpha rao of the subnet. An amount actually paid: the runtime's split line scaled by the recipient hotkey's paid / pre-re-split dividend ratio (per recipient it equals the emission credits within 10 rao on 5,336 of 5,341 hotkeys; the other 5 are validators without parents that epoch, where only the kept-as-parent share is in the split by definition). Paid amounts can be above or below the split line's own figure, and nothing is taken twice: after the childkey split the runtime splits each hotkey's dividends into an alpha part and a root part by its own stake mix, then rescales each side to its fixed share of validator emission (on SN26 one day: alpha x1.391, root x0.680, the total unchanged), so a hotkey's paid / split ratio can exceed 1: validators staked all in alpha are paid above their split figure, root-heavy ones below. Null on an aggregated (cross-subnet) row.

Format: whole number, as a string
kept_as_parent_alpha_raostring · unit alpha_rao (÷1e9) · can be null

Dividends paid to this hotkey as a parent: what its stake weight earned through its children on the subnet after their take. In alpha rao of the subnet. An amount actually paid: the runtime's split line scaled by the recipient hotkey's paid / pre-re-split dividend ratio (per recipient it equals the emission credits within 10 rao on 5,336 of 5,341 hotkeys; the other 5 are validators without parents that epoch, where only the kept-as-parent share is in the split by definition). Paid amounts can be above or below the split line's own figure, and nothing is taken twice: after the childkey split the runtime splits each hotkey's dividends into an alpha part and a root part by its own stake mix, then rescales each side to its fixed share of validator emission (on SN26 one day: alpha x1.391, root x0.680, the total unchanged), so a hotkey's paid / split ratio can exceed 1: validators staked all in alpha are paid above their split figure, root-heavy ones below. Null on an aggregated (cross-subnet) row.

Format: whole number, as a string
take_gained_spot_tao_raostring · unit rao (÷1e9) · can be null

take_gained_alpha_rao at the subnet's day-close spot, floored, rao of TAO; summed over the subnets on an aggregated row (an unpriced subnet adds 0). Null on a per-subnet row whose day is unpriced (with the other two spot members, checked), and on an older answer.

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

take_paid_alpha_rao at spot, as take_gained_spot_tao_rao.

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

kept_as_parent_alpha_rao at spot, as take_gained_spot_tao_rao.

Format: whole number, as a string · on chain: u64
subnetsinteger · unit count · can be null

The subnets in the row (1 on a per-subnet row, checked; at least 1 on an aggregated row). Null on an older answer.

totalsvalue · optional

Detail (include=subnets / daily); absent otherwise. daily and childkey_daily summed over the window.

basketobject · can be null

Only with include=basket (absent otherwise): the fund this hotkey runs, exactly as GET /baskets/{hotkey}'s data at the latest available day end (no sections); its day, coverage and version are meta.sections.basket. Null when the hotkey runs no fund (a hotkey whose staking_options.fund block is set never has a null basket: checked). At most 20 hotkeys per request with it (400 BATCH_TOO_LARGE). With include=basket_holdings (which implies basket) it also carries holdings_by_subnet, as GET /baskets/{hotkey}?include=holdings_by_subnet serves it.

43 fields in basket
hotkeystring

The validator running the fund, SS58 (prefix 42).

Format: SS58 address
account_kindobject

What the hotkey is, from its bytes.

daystring (date)

The UTC day.

Format: date, YYYY-MM-DD
heightinteger · unit block

The day's last block (the day end everything is read at).

shares_unitsstring · unit shares · can be null

BasketShares: the fund's units outstanding. Null when not readable.

Format: whole number, as a string
sum_owed_unitsstring · unit shares

The units owed to the holders, summed (each holder's capped at the fund's units, as the runtime caps it).

Format: whole number, as a string
sum_owed_sourcestring

Always derived (an opaque identifier): a computed sum, not a chain value. New values may be added; show an unknown value as is (or generically).

unowed_shares_unitsstring · unit shares · can be null

shares_units - sum_owed_units: units no holder is owed (from stated facts; their origin is not attributed yet). May be negative by a few units: the runtime's rate accrual over-entitles holders by dust (claims are capped at the fund's shares). Null with shares_units.

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

Always derived (an opaque identifier): a computed figure, not a chain value. New values may be added; show an unknown value as is (or generically).

n_stakersinteger · unit count

The fund's stakers at the day end: the (fund hotkey, coldkey) pairs holding a root share key (Alpha / AlphaV2 on netuid 0) OR a BasketClaimed record, the fund escrow excluded. It includes stakers whose root stake is now 0 with a claim record; dust is not excluded. The stakers with stake are n_stakers_with_stake.

n_stakers_with_stakeinteger · unit count · can be null

The stakers with root stake > 0 at the day end (the count usually shown as "Stakers"): a subset of n_stakers (at most it, checked); dust not excluded. Null on a day from before this figure was recorded, and on an older data version's answer.

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

The runtime's realizable (slippage-aware) NAV at the day's close, rao. Null when the runtime call was not available.

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

The validator's total root stake the owed units accrue on, rao.

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

The NAV at spot prices, rao (labelled spot: not realizable). Null when not available.

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

TAO deposited into the fund, rao. Null when not available.

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

TAO redeemed from the fund, rao. Null when not available.

Format: whole number, as a string · on chain: u64
holdingsinteger · unit count · can be null

Subnet positions the fund holds. Null when not available.

pricingobject

The chain's fund pricing at the day end (BetaBaseline / BasketTwr / BetaIndexSnapshot and the runtime's spot NAV): the same values BetaBasketRuntimeApi.get_beta_pricing returns.

returnsobject

The fund's 7- and 30-day NAV-per-unit returns and the staker's TWR over the same windows.

stakingobject

The validator's staking figures at the served day, blended over its pools (subnets AND root) by each pool's TAO value at its window open; each pool annualised over its own day count. Any staked pool without a value makes a figure null (no partial blend), with unavailable_reason. The top-level figures cover every pool, root included; subnet_only the subnet pools only (netuid != 0).

sparkline_7d_nav_per_unitarray of string · unit rao_per_share · 12 decimals · can be null

The realizable NAV per unit (rao per unit, 12 decimals) at the last 8 UTC day-end closes, oldest first; a day not available yet is absent, a day without units is null. Null on an older data version's answer.

trades_7dinteger · unit count · can be null

BasketSwapped events of the fund over the 7 days (50,400 blocks) to the day end. Null on an older data version's answer.

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

The TAO leg at mid (taoMid) of those swaps, summed, rao. Null on an older data version's answer.

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

Owner(hotkey) at the state head: the coldkey owning the validator, SS58 (prefix 42). Null on an older data version's answer.

Format: SS58 address
owner_namestring · can be null

The owner coldkey's on-chain identity name. Null without one. Null on an older data version's answer.

take_ratiostring · unit ratio · 6 decimals · can be null

Delegates take at the state head (u16 / 65535), a ratio, 6 decimals. Null when unset. Null on an older data version's answer.

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

True when the fund is dissolved: absent from the runtime's basket list at the 2 swept anchors after its last one with units, and its BasketShares gone at the state head. A dissolved fund's page serves its last available day. Null on an older data version's answer.

dissolved_heightinteger · unit block · can be null

The first anchor the fund was absent at. Null unless dissolved. Null on an older data version's answer.

root_uidinteger · unit id · can be null

The fund hotkey's UID on root (netuid 0). Null when it is not registered on root. Null on an older data version's answer.

trading_statusobject · can be null

The fund's swap_basket gate and turnover bucket at the state head (not the served day end): served only when no at is asked (meta.head_fields), null with one. Null too when the fund has no swept holdings, and on an older answer.

nav_unavailable_reasonstring · can be null

Why nav_tao_rao is null: no_nav_row (no NAV row swept at the day end). Null otherwise, and on an older answer. Known values: no_nav_row, unpriced_holding, fund_dissolved. New values may be added; treat unknown values as unavailable.

pending_depositsarray of objects · can be null

The fund's dividends queued for it per subnet and not yet flushed in, at the state head, by netuid; [] when none. Raw alpha, never valued: not part of any NAV or total. Null when an at is asked (read at the head only: meta.head_fields). Null on an older data version's answer.

holding_countinteger · unit count · can be null

The subnets the fund holds alpha in (alpha > 0) at its newest swept anchor at or before the day end: the same composition as include=holdings_by_subnet, counted. Null before the fund's first swept anchor. Null on an older data version's answer.

root_stakeobject · can be null

Option A: root stake to the fund's validator, with its holder-true accrual, realised claims, staker TWR and hold return as RatioFigures. Never combined with fund (no rate across options). Stored once per accrual day with its own as_of_day / as_of_height: the block of the latest accrual day, whatever day the list serves (so an answer carrying it is never cached as settled). Null before the fund's first store.

fundobject · can be null

Option B: the fund units, the full block (state, NAVs and unit values, holder returns, composition, trading, display, risk). Stored once per accrual day like root_stake, with its own as_of_*. Null when not stored.

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

The validator's stake on the subnets (netuid >= 1) at spot, rao of TAO (the validators index): a value, never a rate. Null when any staked pool is unpriced (never a partial sum) or the hotkey is not indexed. Null on an older data version's answer.

Format: whole number, as a string · on chain: u64
staked_subnet_countinteger · unit count · can be null

Subnets where the validator's pool holds stake (TotalHotkeyAlpha > 0; the validators index): a count, never a rate. Null when the hotkey is not indexed. Null on an older data version's answer.

first_funded_heightinteger · unit block · can be null

The first block with units outstanding (BasketShares > 0) at or before the served day end: where the fund was first funded, as far as the data source reaches back (first_funded_is_lower_bound). Null when the fund had no units outstanding by the day end (with the flag). Null on an older data version's answer.

first_funded_is_lower_boundboolean · can be null

True when first_funded_height is the data source's first recorded block for this fund (it was funded at or before it, so the true first block may be older and a fund age from it is a minimum); false when it is the exact first funded block. Null exactly with first_funded_height.

seriesarray of objects · optional

Only with include=series (absent otherwise): the fund's day ends of the 90 days ending at meta.day (fewer near the first available day), oldest first; each with that day's pricing.

holdersarray of objects · optional

Only with include=holders (absent otherwise): the first child_limit holders at meta.day, by owed units descending, as GET /baskets/{hotkey}/holders?day=<meta.day>&limit=<child_limit> answers them; meta.sections.holders.page.next_cursor continues that request.

holdings_by_subnetobject · can be null

Only with include=holdings_by_subnet (absent otherwise): the runtime's per-subnet holdings (BasketSummary.holdings) at the fund's latest swept anchor at or before the day end. Null before the first sweep that kept them (they are stored from 2026-10-03 on).

eventsarray of objects · optional

Only with include=events (absent otherwise): the fund's newest child_limit events (BasketDeposited, BasketClaimed, BasketSwapped, BasketClaimDustSkipped, BasketStakedIn, BasketAlphaWrittenOff, BasketHoldingConverted) at the head, not the day end, as GET /baskets/{hotkey}/events?limit=<child_limit> answers them; meta.sections.events.page.next_cursor continues that request.

labelobject · can be null

Only with include=label (absent otherwise): the address's own label and the entity it names, as GET /labels/{address} answers them (both null for an address without a label). Null when that read is unavailable (meta.sections.label.unavailable_reason). Head only: with an at the request is a 400 INCLUDE_AT_HEAD_ONLY, and an answer carrying it is cached like a head answer (tip).

2 fields in label
labelobject · can be null

Its label; null for an account without one.

7 fields in label
labelstring

The display name of the labelled account (e.g. Binance).

sublabelstring · can be null

A finer role within the entity (e.g. deposit, hot wallet); null when none.

entity_idstring · can be null

The entity the label names (/api/v2/entities/{id}; may contain /); null when none.

entity_kindstring · can be null

The entity's kind: exchange, validator, pallet, ... (an open set); null when none.

inferredboolean

True when the label is attributed by a heuristic (most labels): show it as likely, never as a fact.

verifiedboolean

True when the label is confirmed on chain or by the entity itself.

confidencestring · unit ratio · can be null

How sure the attribution is, a decimal string 0..1 (e.g. 0.95); null when not scored.

Pattern: ^[0-9]\.[0-9]+$
entityobject · can be null

The entity the label names (label.entity_id); null without a label or an entity.

6 fields in entity
idstring

The entity's id, stable across runs (may contain /, e.g. pallet-bt/cloan).

namestring

Its display name.

kindstring

Its kind: exchange, validator, pallet, ... (an open set).

urlstring · can be null

Its website; null when none.

descriptionstring · can be null

A short plain-text description; null when none.

member_countinteger · unit count

How many accounts carry a label naming it.

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.