Kusama Data: Index KSM Transfers and Kusama Hub Extrinsics

Index Kusama Hub extrinsics and KSM transfers, delivered to your own database. Real-time and complete historical data, no node to run.

Kusama calls itself web3's untamed frontier: a wild, permissionless network where code goes to get weird, now pushing into ZK and bleeding-edge parts of the stack. It runs the same Substrate and parachain architecture as Polkadot, with a relay chain for security and system parachains for everyday activity. Indexing Co's Kusama feed follows Kusama Hub (formerly Kusama Asset Hub), the system parachain where KSM balances and assets move. You can read how the project frames itself at kusama.network.

Kusama Hub is a Substrate chain, so its native activity arrives as extrinsics, not EVM logs. Kusama Hub also runs Ethereum-compatible smart contracts, and calls to them arrive as extrinsics too. Each block is a header plus a list of extrinsics, and each extrinsic is a pallet call such as balances.transferKeepAlive with a signer, a nonce, and positional arguments. Indexing Co covers Kusama Hub in a single pipeline, lets you shape those extrinsics into rows, and delivers them to your own PostgreSQL, warehouse, or webhook. Real-time and full history, with no node to operate.

Source Kusama Hub

Ingest header + extrinsics

Decode pallet.call + args

Transform your JavaScript

Deliver your database

Why Kusama data is hard

Which Kusama Chain? Kusama is a relay chain plus a set of parachains, and KSM transfers happen on Kusama Hub, not on the relay chain. Point a pipeline at the wrong chain and you get consensus plumbing instead of user activity.

Mostly Inherents, Then a Burst Many Kusama Hub blocks carry only parachainSystem.setValidationData and timestamp.set. Real activity arrives in between. Your pipeline has to skip the inherents cheaply and never drop the signed extrinsics that matter.

Positional Call Arguments A balances.transferKeepAlive call carries its destination as an Id object and its amount as a comma-formatted planck string, by position rather than by name. Each call you track needs its own argument mapping and number normalization.

A Network That Changes Fast Kusama exists to ship new runtime features early. Runtime upgrades change call signatures and pallets over time, so a decoder pinned to one metadata version eventually reads history wrong.

What Indexing Co delivers for Kusama

The DIY Path

Stand up and maintain the Substrate stack yourself.

Run a Kusama Hub archive node or rent a Substrate RPC.
Decode extrinsics against the right runtime metadata per block.
Map positional args per call and normalize planck amounts.
Build backfill, runtime-upgrade handling, and delivery from scratch.

Indexing Co

One pipeline sources, decodes, and delivers Kusama Hub to your store.

Every extrinsic with its method, signer, nonce, hash, and decoded args.
Shaped by your JavaScript transform, filtered to the calls you need.
Lands in your PostgreSQL, BigQuery, warehouse, or webhook.
Real-time delivery plus complete backfilled history. No node, no RPC babysitting.

What you can index

Kusama Hub data	For example
KSM transfers	`balances.transferKeepAlive` with sender, destination, and amount
Signed extrinsics	Any `pallet.call` with its signer, nonce, and args
Account activity	Per-signer history and nonce ordering
Block headers	Block number, hash, parent hash, and `timestamp.set` time

A transform, not a subgraph

You write the transform in JavaScript, not AssemblyScript, and change it without re-indexing from block zero. Indexing Co runs your function over each block server-side: pick the extrinsics you care about and return rows for your destination.

// Indexing Co transform: KSM transfers on Kusama Hub as rows
function transform(block) {
  const results = [];

  for (const ext of block.extrinsics || []) {
    if (!ext.method.startsWith('balances.transfer')) continue;
    const [dest, amount] = ext.args;
    results.push({
      chain: block._network,
      block: block.blockNumber,
      extrinsic_hash: ext.hash,
      call: ext.method,
      from: ext.signer,
      to: dest.Id,
      amount_planck: amount.replace(/,/g, ''),
    });
  }
  return results;
}

Kusama with Indexing Co

Run it yourself if

You want full control of Substrate infrastructure and have the team to operate a Kusama Hub archive node, keep up with frequent runtime upgrades, and build backfill and delivery in-house.

Use Indexing Co if

You want KSM transfers and Kusama Hub extrinsics delivered to your own database as clean rows, with real-time plus complete history and no node to run.

Get a Demo Open the Console

FAQ

Is this the Kusama relay chain or Kusama Hub?

Kusama Hub. Indexing Co's Kusama feed follows the Kusama Hub system parachain (formerly Kusama Asset Hub), where KSM balances move. Every block includes the parachainSystem.setValidationData inherent that parachain blocks carry.

What is in each Kusama block?

The block number, block hash, and header, plus an array of extrinsics. Each extrinsic carries its index, hash, signer, nonce, method in pallet.call form, and its decoded arguments.

Do I need to run a Kusama node?

No. Indexing Co sources Kusama Hub blocks for you, including full history, so you never operate an archive node or track runtime metadata yourself.

How do I handle KSM amounts?

Amounts arrive in planck as comma-formatted strings. Strip the commas in your transform, as in the example above, and store them as numeric or string columns at full precision.

Where does the Kusama data go?

Into your own destination: PostgreSQL, BigQuery, a warehouse, or a webhook. You define the output schema and own the storage.

Get Started

Index Kusama in minutes. Set up your first KSM transfer pipeline without running a node.