Skip to content
TAO$188.40
BTC0.00293
MCap$2.21B
Vol$86.07M

API reference / Extrinsics

One extrinsic

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

One extrinsic by id or hash: the slim row plus its block hash, the block's extrinsic count (to bound previous / next), format version, nonce, era, signature, metadata-hash mode, the decoded error when it failed, the named args, and call_summary (its call tree counted by kind and outcome).

Full description

One extrinsic by id or hash: the slim row plus its block hash, the block's extrinsic count (to bound previous / next), format version, nonce, era, signature, metadata-hash mode, the decoded error when it failed, the named args, and call_summary (its call tree counted by kind and outcome). One call per page view: include adds events, calls and / or changes as rows (the first child_limit of each, in the child routes' row shape; changes is /changes' default view, system rows excluded), each with its page meta in meta.sections.<name> (truncated when more rows exist; page.next_cursor then continues the child route called with limit = child_limit), and raw (the SCALE hex). A section that fails fails the whole call (the changes' CHANGES_NOT_INDEXED / NOT_READY included). meta.settled is meta.at.finalized. An extrinsic at or below meta.at is final and cached as settled, sections included. Ids: an extrinsic or an event is {height}-{index}, a call {height}-{extrinsic index} then .{child} per level (9190000-5.0.1); leading zeros are dropped. Anything else is a 400 INVALID_ID. Earlier id forms are accepted too: zero-padded (0009190000-000005), and on /calls/{id} the call ids {height}-{extrinsic}-{n} (an executed call; n counts the extrinsic's executed calls in postorder, not a position:0009190005-000006-000001 is 9190005-6.1) and {height}-{extrinsic}-s{path} (a never-dispatched call: 0009155314-000010-s000000.000003 is 9155314-10.0.3). The answer is the canonical id's, and a Content-Location header names the canonical URL whenever the path's id was not in canonical form (no redirect). Accounts at the top level of a row (signer, wrapped.real, origin.account, tx_fee.payer, gas_fee.payer) are SS58; gas_fee.from stays the EVM sender's H160 hex. args are named fields as the data source renders them (accounts in them already SS58), versioned by meta.data_version's args/... part. Errors are application/problem+json: INVALID_ID, INVALID_INCLUDE, INVALID_CHILD_LIMIT, EXTRINSIC_NOT_FOUND (404; asked by hash, an extrinsic not seen yet carries extension member indexed_through_height, the newest finalized block processed: a later retry may find it), EXTRINSIC_OUT_OF_COVERAGE (404, below meta.coverage.from_height while earlier history is still being prepared), EXTRINSIC_NOT_YET_INDEXED (404, above the indexed head; extension members head_height and indexed_through_height), AMBIGUOUS_HASH (409: more than one extrinsic has this hash; extension member candidates, their ids, oldest first: ask by id), CHANGES_NOT_INDEXED (404, with include=changes), UNKNOWN_PARAMETER, SOURCE_TIMEOUT (503), SOURCE_NOT_READY (503). Asked by hash and not seen yet, the 404 EXTRINSIC_NOT_FOUND also carries details, an ExtrinsicStatus (status not_seen, the hash asked for, indexed_through_height; the block members null). This route serves only finalized (the extrinsic itself) and not_seen; in_block and expired appear only on the live stream.

Path parameters

id_or_hashpath, required· string

The extrinsic id, {height}-{index} (e.g. 9190000-5), or its hash, 0x + 64 hex (any case). A hash is a lookup alias: when several extrinsics share it, the answer is a 409 AMBIGUOUS_HASH listing their ids.

Query parameters

includequery· string

Sections to add, a comma list (or the parameter repeated); each is absent without it. Anything else is a 400 INVALID_INCLUDE.

includeaddscapmeasured cost
eventsdata.events: its events by position (GET /extrinsics/{id}/events rows); meta.sections.eventschild_limitsmall
callsdata.calls: its call tree in preorder (GET /extrinsics/{id}/calls rows); meta.sections.callschild_limitsmall
changesdata.changes: the storage entries it changed, netted (GET /extrinsics/{id}/changes rows, system rows excluded); meta.sections.changeschild_limitthe heaviest: decodes every value
rawdata.raw: the SCALE hexone stringsmall

events,calls,changes together: 0.4-0.6 s (measured).

child_limitquery· integer · default 1000 · 1 to 1000

Rows per included section, 1..1000 (default 1000, the data source's own); anything else is a 400 INVALID_CHILD_LIMIT. A section is its child route's first page with limit = child_limit, so its meta.sections.<name>.page.next_cursor is valid on that route called with the same id and limit = child_limit (a cursor is bound to its limit). Ignored without include.

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

idstring · unit id

The extrinsic's id, {height}-{index} (the canonical id; the hash is a lookup alias only).

Format: block and index, such as 4200000-3
heightinteger · unit block

The block it is in.

indexinteger · unit id

Its index in the block (0-based; inherents first).

hashstring

The extrinsic hash, 0x + 64 lower-case hex. Not unique: an identical extrinsic can recur.

Format: 32-byte hex: 0x and 64 hex digits
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
callobject

The extrinsic's own (top-level) call.

2 fields in call
palletstring

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

namestring

The call, as in the runtime metadata (snake_case, e.g. add_stake).

signerstring · can be null

The signing account, SS58 (the source's 0x hex, rendered). Null for inherents and unsigned extrinsics.

Format: SS58 address
successboolean

Whether the extrinsic's call succeeded (System.ExtrinsicSuccess).

tx_feeobject · can be null

The Substrate transaction fee the chain states for this extrinsic: payer, asset, amount_rao (in the paid asset, the tip excluded), tip_rao, and for an alpha fee tao_equivalent_rao. The whole fee in TAO terms is amount_rao + tip_rao (tao) or tao_equivalent_rao + tip_rao (alpha). Null when none was charged: inherents, unsigned extrinsics and Ethereum.transact (which pays EVM gas only, in gas_fee).

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 EVM gas the chain settled for this extrinsic, always TAO: payer, from (the H160 sender), amount_rao (the base fee only). Present on Ethereum.transact and EVM.call / EVM.create; null on every other extrinsic.

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
event_countinteger · unit count

Events the extrinsic emitted (phase extrinsic).

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.

3 fields in wrapped
countinteger · unit count

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

callsarray of objects

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

3 fields in calls (each item)
palletstring

The inner call's pallet.

namestring

The inner call's name.

countinteger · unit count

How many direct inner calls of this kind.

realstring · can be null

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

Format: SS58 address
evm_tx_hashstring · can be null

For Ethereum.transact: the EVM transaction's hash, 0x + 64 lower-case hex (what an EVM explorer and wallets show; not the extrinsic hash). Null on every other call, and on a transact the EVM never ran (rejected before dispatch, e.g. CallFiltered: there is no EVM transaction).

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

The runtime upgrade this row carries: on a System.set_code / set_code_without_checks call row, its code; on an extrinsic row, the code of a set_code call anywhere in its call tree (e.g. under Sudo.sudo). The code itself is never served (its args are withheld above 16 KiB, see args_truncated). Null on every other row, and on an answer read before the source served it.

4 fields in runtime_code
code_hashstring

blake2_256 of the runtime code bytes the call carried (the blob stored at :code; the hash node tooling reports for a runtime), 0x + 64 lower-case hex.

Format: 32-byte hex: 0x and 64 hex digits
code_bytesinteger · unit count

The runtime code's size in bytes (the wasm blob, not its hex).

spec_version_afterinteger · unit id · can be null

The runtime spec that executed the next block (the upgrade's result). Null when the call did not succeed (no upgrade happened).

download_urlstring · can be null

Where to download this code: our published copy (the file GET /api/v2/runtimes/{spec_version}/code links, matched by code_hash; static storage, no API key). Null when it is not published: not yet (the publishing job runs after an upgrade), or never (a failed upgrade's code never ran on chain).

multisig_operationobject · can be null

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

4 fields in multisig_operation
accountobject

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

2 fields in account
ss58string

The account, SS58 (prefix 42).

Format: SS58 address
hexstring

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

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

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

2 fields in timepoint
heightinteger · unit block

Its block.

indexinteger · unit id

Its extrinsic index in the block.

call_hashstring · can be null

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

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

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

block_hashstring

The block's hash, 0x + 64 lower-case hex.

Format: 32-byte hex: 0x and 64 hex digits
block_extrinsic_countinteger · unit count

Extrinsics in the block, so the previous / next ids are known without fetching the block.

versioninteger · unit id · can be null

The extrinsic format version (e.g. 4); null when not recorded.

nonceinteger · unit count · can be null

The signer's nonce; null for unsigned extrinsics.

mortalityobject · can be null

The era; null for an immortal or unsigned one.

2 fields in mortality
periodinteger · unit blocks

The era's length in blocks.

phaseinteger · unit blocks

The era's phase: the offset of the birth block within the period.

signatureobject · can be null

The signature; null for unsigned extrinsics.

2 fields in signature
typestring

The signature scheme, lower-case (sr25519, ed25519, ecdsa).

valuestring · unit id · can be null

The signature bytes, 0x + lower-case hex (opaque: x-unit id, never a quantity).

Format: hex: 0x and hex digits
metadata_hash_modestring · can be null

The CheckMetadataHash extension's mode, lower-case (disabled, enabled); null when the extension is absent.

errorobject · can be null

Why the extrinsic failed; null when it succeeded.

5 fields in error
kindstring

The DispatchError variant in snake_case: module (a pallet's error: pallet, name, docs), bad_origin, token, arithmetic, cannot_lookup, ... (an open set), or other when the error could not be decoded (raw then carries it).

palletstring · can be null

The pallet that raised a module error; null for other kinds.

namestring · can be null

The pallet error's name (e.g. SlippageTooHigh); null for other kinds or when not decoded.

docsstring · can be null

The error's documentation from the runtime metadata; null when there is none.

rawobject · can be null

Only when the error could not be decoded (kind other, or a module error without a name): the stored error value as decoded JSON (an object). Absent otherwise.

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. Null also when args_truncated is true.

args_truncatedboolean

True when the args are larger than 16 KiB (16384 bytes) of JSON: args is then null and args_bytes gives their size. Only runtime upgrades (System.set_code and every wrapper around it: Sudo.sudo, Proxy.proxy, Multisig.as_multi) and very large batches get that big; a batch's children are rows of their own (/extrinsics/{id}/calls). The full args are not served by this API (read the block from a chain node). False otherwise.

args_bytesinteger · unit count · can be null

When args_truncated is true: the args' size in bytes of JSON (above 16384). Null when the args are served (and on an extrinsic's call rows read before the source stated the size).

call_summaryobject

The call tree counted by kind and outcome.

2 fields in call_summary
call_countinteger · unit count

Calls in the tree, the extrinsic's own call included.

by_callarray of objects

One entry per call kind, in the order each kind first appears in the tree (preorder).

8 fields in by_call (each item)
palletstring

The call's pallet.

namestring

The call's name.

is_wrapperboolean

True when a call of this kind dispatched inner calls.

countinteger · unit count

Calls of this kind in the tree (every level).

executedinteger · unit count

Of them, executed and succeeded (status executed, success).

revertedinteger · unit count

Of them, executed but rolled back by an enclosing failure (status reverted).

not_executedinteger · unit count

Of them, never dispatched (status not_executed).

failedinteger · unit count

Of them, executed and failed themselves (status executed, not success).

statusstring · can be null

The extrinsic's lifecycle state. This API serves finalized blocks only, so an extrinsic found here is finalized (in a finalized block). The live stream also emits in_block (in a block not yet finalized), expired (a mortal extrinsic past its validity period, never included) and not_seen (not in any block yet); here, an extrinsic not seen yet is a 404 carrying indexed_through_height and, asked by hash, details (its not_seen status). Null while the state is not available yet. New values may be added; show an unknown value as is (or generically).

status_heightinteger · unit block · can be null

The block height at which the extrinsic reached status: for finalized, its own block's height (= height). Null when status is null.

rawstring · can be null

Only with include=raw (absent otherwise): the extrinsic's SCALE encoding, 0x + lower-case hex.

Format: hex: 0x and hex digits
eventsarray of objects · optional

Only with include=events (absent otherwise): its first child_limit events by position, as GET /extrinsics/{id}/events?limit=<child_limit> answers them; meta.sections.events holds that page's meta (exact total; truncated and page.next_cursor, which continues GET /extrinsics/{id}/events?limit=<child_limit>&cursor=...: a cursor is bound to its limit).

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

The event's id, {height}-{index} (index = its position in the block's System.Events).

Format: block and index, such as 4200000-3
heightinteger · unit block

The block it was emitted in.

indexinteger · unit id

Its index in the block's System.Events (0-based).

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
phasestring

When it was emitted: initialization (block hooks before the extrinsics, e.g. emission), extrinsic (while applying an extrinsic) or finalization (block hooks after them; none after block 9,155,260). New values may be added; show an unknown value as is (or generically).

extrinsic_idstring · unit id · can be null

The extrinsic it was emitted under ({height}-{index}); null in the initialization and finalization phases.

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

Where in applying its extrinsic the event was emitted, from the chain's per-event trace: pre_dispatch (before the call ran: the fee withdraw), dispatch (by the call or the calls it dispatched) or post_dispatch (after it: the fee refund, TransactionFeePaid, System.ExtrinsicSuccess / ExtrinsicFailed). Null outside the extrinsic phase, and below block 7,089,968 (before the trace covers). New values may be added; show an unknown value as is (or generically).

call_idstring · unit id · can be null

The call that emitted it (a call id). Null outside a dispatched call: the block phases, and the extrinsic's pre- and post-dispatch events (dispatch_phase pre_dispatch / post_dispatch: the fee withdraw, the refund, TransactionFeePaid, ExtrinsicSuccess / ExtrinsicFailed), which no call emits, so per-call event lists and counts never include them. Below block 7,089,968 (dispatch_phase null) the attribution is the event dictionary's, which puts a wrapper's pre-dispatch events on its first child.

Pattern: ^[0-9]+-[0-9]+(\.[0-9]+)*$
eventobject

The event's kind.

2 fields in event
palletstring

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

namestring

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

argsobject · can be null

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

error_palletstring · can be null

The DispatchError this event carries, decoded with the block's runtime: for a module error the pallet that raised it (e.g. Swap), as an extrinsic's error.pallet. Carried by System.ExtrinsicFailed, Utility.BatchInterrupted / ItemFailed, and the Err results of Proxy.ProxyExecuted, Multisig.MultisigExecuted, Sudo.Sudid / SudoAsDone, Utility.DispatchedAs and Scheduler.Dispatched. Null on every other event, on an Ok result, for a non-module error (BadOrigin, Token, ...) and when the error could not be decoded.

error_namestring · can be null

The DispatchError's name, as an extrinsic's error.name: a module error's (e.g. PriceLimitExceeded, HotKeyAlreadyRegisteredInSubNet), or the inner variant of a Token / Arithmetic / Transactional error (error_pallet then null). Null when the event carries no DispatchError, or it has no name (BadOrigin, an undecoded error).

positioninteger · unit id

Its 0-based position among the extrinsic's events (dense; from_index / to_index page by it).

callsarray of objects · optional

Only with include=calls (absent otherwise): its first child_limit calls in preorder, as GET /extrinsics/{id}/calls?limit=<child_limit> answers them (meta.sections.calls as for events).

23 fields in calls (each item)
idstring · unit id

The call's id: the extrinsic id for its own call (9190000-5), then .{child} per level (9190000-5.0.1), so a call id starts with its extrinsic id.

Pattern: ^[0-9]+-[0-9]+(\.[0-9]+)*$
extrinsic_idstring · unit id

The extrinsic ({height}-{index}).

Format: block and index, such as 4200000-3
heightinteger · unit block

The block it is in.

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
depthinteger · unit count

Level in the tree: 0 for the extrinsic's own call.

parent_idstring · unit id · can be null

The call that dispatched it; null for the extrinsic's own call.

Pattern: ^[0-9]+-[0-9]+(\.[0-9]+)*$
callobject

The call's kind.

2 fields in call
palletstring

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

namestring

The call, as in the runtime metadata (snake_case, e.g. add_stake).

originobject · can be null

The origin it was dispatched with; null when none is recorded (inherents, and calls that were never dispatched or were rolled back).

3 fields in origin
kindstring

signed (an account: the signer, or the proxied account inside Proxy.proxy), root (e.g. inside Sudo.sudo), none (unsigned) or other (any other origin: raw carries it). New values may be added; show an unknown value as is (or generically).

accountstring · can be null

For signed: the account, SS58 (the source's 32-byte hex, rendered). Null for the other kinds.

Format: SS58 address
rawobject · can be null

Only for kind other: the stored origin as decoded JSON (an object). Absent otherwise.

statusstring

executed (it ran; see success), reverted (it ran but an enclosing failure rolled it back, e.g. in a failed batch_all) or not_executed (never dispatched: a batch stopped before it, or a proxy check failed). New values may be added; show an unknown value as is (or generically).

successboolean

True when it executed and succeeded; false otherwise.

errorobject · can be null

Why it failed, when it executed and failed itself; null otherwise.

5 fields in error
kindstring

The DispatchError variant in snake_case: module (a pallet's error: pallet, name, docs), bad_origin, token, arithmetic, cannot_lookup, ... (an open set), or other when the error could not be decoded (raw then carries it).

palletstring · can be null

The pallet that raised a module error; null for other kinds.

namestring · can be null

The pallet error's name (e.g. SlippageTooHigh); null for other kinds or when not decoded.

docsstring · can be null

The error's documentation from the runtime metadata; null when there is none.

rawobject · can be null

Only when the error could not be decoded (kind other, or a module error without a name): the stored error value as decoded JSON (an object). Absent otherwise.

event_countinteger · unit count

Events this call emitted (its call_id). Pre- and post-dispatch events (the fee withdraw, refund, TransactionFeePaid, ExtrinsicSuccess / ExtrinsicFailed) belong to no call and are not counted (from block 7,089,968; below it the event dictionary's attribution).

is_wrapperboolean

True when the call dispatched inner calls (it has child rows: a batch, proxy, sudo, ...).

deferred_bystring · can be null

Why a not_executed call did not run when it was not refused but kept for later: multisig = a Multisig.as_multi that was not the final approval stored it, waiting for the remaining approvals (it runs in the extrinsic carrying the last one). The call did not run here; deferred_by says why. Null on every other call (and on an answer read before the source served it). Only multisig is defined. New values may be added; show an unknown value as is (or generically).

runtime_codeobject · can be null

The runtime upgrade this row carries: on a System.set_code / set_code_without_checks call row, its code; on an extrinsic row, the code of a set_code call anywhere in its call tree (e.g. under Sudo.sudo). The code itself is never served (its args are withheld above 16 KiB, see args_truncated). Null on every other row, and on an answer read before the source served it.

4 fields in runtime_code
code_hashstring

blake2_256 of the runtime code bytes the call carried (the blob stored at :code; the hash node tooling reports for a runtime), 0x + 64 lower-case hex.

Format: 32-byte hex: 0x and 64 hex digits
code_bytesinteger · unit count

The runtime code's size in bytes (the wasm blob, not its hex).

spec_version_afterinteger · unit id · can be null

The runtime spec that executed the next block (the upgrade's result). Null when the call did not succeed (no upgrade happened).

download_urlstring · can be null

Where to download this code: our published copy (the file GET /api/v2/runtimes/{spec_version}/code links, matched by code_hash; static storage, no API key). Null when it is not published: not yet (the publishing job runs after an upgrade), or never (a failed upgrade's code never ran on chain).

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

intended_originobject · can be null

The origin the call ran with, or would have run with: origin when it was dispatched; for a reverted or not_executed call, its batch's origin through Utility.batch / batch_all / force_batch wrappers (null under any other wrapper, where the origin it would have had is not known). GET /calls?origin= matches this member. Null also on an answer read before the source served it.

3 fields in intended_origin
kindstring

signed (an account), root (e.g. inside Sudo.sudo), none (unsigned) or other (any other origin: raw carries it). New values may be added; show an unknown value as is (or generically).

accountobject · can be null

For signed: the account, as {ss58, hex}. Null for the other kinds.

rawobject · can be null

Only for kind other: the stored origin as decoded JSON (an object). Absent otherwise.

extrinsic_hashstring · can be null

The hash of the call's extrinsic, 0x + 64 lower-case hex. Null only on an answer read before the source served it.

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

The hash of the call's block, 0x + 64 lower-case hex. Null only on an answer read before the source served it (the call detail has always served it).

Format: 32-byte hex: 0x and 64 hex digits
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. Null also when args_truncated is true.

args_truncatedboolean

True when the args are larger than 16 KiB (16384 bytes) of JSON: args is then null and args_bytes gives their size. Only runtime upgrades (System.set_code and every wrapper around it: Sudo.sudo, Proxy.proxy, Multisig.as_multi) and very large batches get that big; a batch's children are rows of their own (/extrinsics/{id}/calls). The full args are not served by this API (read the block from a chain node). False otherwise.

args_bytesinteger · unit count · can be null

When args_truncated is true: the args' size in bytes of JSON (above 16384). Null when the args are served (and on an extrinsic's call rows read before the source stated the size).

positioninteger · unit id

Its 0-based position in the extrinsic's call tree in preorder (dense; from_index / to_index page by it).

changesarray of objects · optional

Only with include=changes (absent otherwise): the first child_limit storage entries it changed, netted over the extrinsic, as GET /extrinsics/{id}/changes?limit=<child_limit> answers them by default (system rows excluded); meta.sections.changes holds that page's meta (attribution included), its page.next_cursor continues that request.

14 fields in changes (each item)
itemobject

The storage item (pallet and name).

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

classstring · optional

fee = the fee payer's writes, which can differ from the signer (proxy real-pays): the payer's (TransactionFeePaid.who) System.Account entry when its change includes the transaction fee debit (or a post-dispatch refund), or, for a fee paid in alpha, the payer's alpha position (Alpha / AlphaV2) the fee extension sold, in the fee phases; system=false keeps them. The pool side of an alpha fee stays bookkeeping (hidden by system=false, no class). Absent otherwise (always absent when meta.attribution is none). On an older data version's answer it is the signer's System.Account entry.

keyobject

The entry's key as named fields: hotkey / coldkey where the key is identified as one, else by type (netuid, account, account_1, u32, ...); accounts SS58. {} for a plain value (an item without key). Free-form: the members depend on the item.

opstring

What happened to the entry: created (absent before, present after), removed (present before, absent after), set (present on both sides with a different value). An entry whose final value equals the one before (restored, or every write rolled back) is not a change and is not listed: include=all_writes lists every write instead. New values may be added; show an unknown value as is (or generically).

beforeobject

The entry before the extrinsic's first write to it.

3 fields in before
rawstring · can be null

The stored bytes (SCALE), 0x hex; null when the entry is absent on this side (before a creation, after a removal). value is then null too.

Format: hex: 0x and hex digits
valuevalue

The value decoded, exact or null: a number (balances, alpha, shares, counters) is a decimal string in unit (fixed-point shares keep their exact decimals); anything else is the value as JSON with the explorer's args conventions: struct fields by their metadata names (snake_case), accounts SS58, integers of 64 bits and more as decimal strings, enums as {__kind, value}, bytes and hashes as 0x hex. Null whenever raw is null (the entry is absent on this side: before a creation, after a removal), and null when the bytes could not be decoded (decoded false).

decodedboolean · can be null

Whether raw decoded: true when value is its exact decoding, false when the entry is present but its bytes could not be decoded (value is then null and only raw says what was stored), null when raw is null (nothing on this side to decode). Tells an undecodable entry from an absent one without the row.

afterobject

The entry after the extrinsic's last write to it that was not rolled back (a write inside a reverted call or a failed extrinsic does not count).

3 fields in after
rawstring · can be null

The stored bytes (SCALE), 0x hex; null when the entry is absent on this side (before a creation, after a removal). value is then null too.

Format: hex: 0x and hex digits
valuevalue

The value decoded, exact or null: a number (balances, alpha, shares, counters) is a decimal string in unit (fixed-point shares keep their exact decimals); anything else is the value as JSON with the explorer's args conventions: struct fields by their metadata names (snake_case), accounts SS58, integers of 64 bits and more as decimal strings, enums as {__kind, value}, bytes and hashes as 0x hex. Null whenever raw is null (the entry is absent on this side: before a creation, after a removal), and null when the bytes could not be decoded (decoded false).

decodedboolean · can be null

Whether raw decoded: true when value is its exact decoding, false when the entry is present but its bytes could not be decoded (value is then null and only raw says what was stored), null when raw is null (nothing on this side to decode). Tells an undecodable entry from an absent one without the row.

unitstring · can be null

The unit a numeric value is in, when the item's is known: rao (TAO), alpha_rao (the subnet's alpha), share (pool shares, fixed point), ...; the same unit GET /storage/{pallet}/{item} states for the item. Null otherwise (not a single amount, or not known). Open vocabulary.

decodedboolean · can be null

True when value is the exact decoding of raw on both sides (or the side is absent); false when the bytes could not be decoded (value is then null and only raw says what was stored). before.decoded / after.decoded say it per side.

writesinteger · unit count

How many times the extrinsic wrote the entry (in this view: system and call apply).

rolled_back_writesinteger · unit count

How many of those writes were rolled back (inside a reverted call, or a failed extrinsic): they do not count towards after.

call_idsarray of string

The calls whose writes touched the entry ({height}-{index} then .{child} per level, as GET /api/v2/calls/{id}); [] when no write is attributed to a call (before or after dispatch, or meta.attribution none).

positioninteger · unit count

The row's place in the extrinsic's changes, 1-based and dense (by item, then key). With item the rows listed keep their place, so a row reads the same with and without the filter.

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

Alpha position rows only (SubtensorModule Alpha / AlphaV2, whose value is pool shares): the position's alpha before the extrinsic, in rao of the subnet's alpha, computed here as before.value (shares) x the pool's TotalHotkeyAlpha / its share total (TotalHotkeyShares for Alpha, TotalHotkeySharesV2 for AlphaV2), both read on the same side from this extrinsic's changes of the same hotkey and subnet, floored to a whole rao (the chain's own fixed-point arithmetic can differ by a few rao). An absent entry is 0 shares, so a created position's alpha_before_rao and a removed one's alpha_after_rao are 0. Null when that side cannot be sized (alpha_unavailable_reason). Absent on every other row.

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

Alpha position rows only (SubtensorModule Alpha / AlphaV2, whose value is pool shares): the position's alpha after the extrinsic, in rao of the subnet's alpha, computed here as after.value (shares) x the pool's TotalHotkeyAlpha / its share total (TotalHotkeyShares for Alpha, TotalHotkeySharesV2 for AlphaV2), both read on the same side from this extrinsic's changes of the same hotkey and subnet, floored to a whole rao (the chain's own fixed-point arithmetic can differ by a few rao). An absent entry is 0 shares, so a created position's alpha_before_rao and a removed one's alpha_after_rao are 0. Null when that side cannot be sized (alpha_unavailable_reason). Absent on every other row.

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

Present with alpha_before_rao / alpha_after_rao: why a side is null, else null. pool_totals_not_on_page: the pool's TotalHotkeyAlpha / share-total rows are not on this page (ask with item=SubtensorModule.Alpha,SubtensorModule.AlphaV2, which sizes every alpha row over all of the extrinsic's changes, or a larger limit); pool_totals_unchanged: the extrinsic did not change the pool's totals (a move between coldkeys on one hotkey, say), so read them with GET /storage/SubtensorModule/TotalHotkeyAlpha?key=[hotkey,netuid]&at= at the block before and at the extrinsic's block; pool_shares_zero: the pool's share total is 0 on that side; not_decoded: a value did not decode; pool_not_identified: the key names no hotkey and subnet. New values may be added; treat unknown values as unavailable.

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 · 409 · 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.