Cosmos Hub Data: Index ABCI Events, IBC Transfers, and Staking

Index Cosmos Hub transaction results, ABCI events, IBC transfers, and staking activity, delivered to your own database. Real-time and complete historical data, no gaiad node to run.

The Cosmos Hub is the first of many interconnected blockchains built on the interchain stack: CometBFT for consensus, the Cosmos SDK for application logic, and IBC for moving tokens and messages between chains. Its native token is ATOM, which holders delegate to validators to secure the network through Proof-of-Stake and use to vote on onchain governance. It is not an EVM chain, so there are no contract logs to decode.

Instead, every block carries ABCI events: typed records with key and value attributes, emitted per transaction and at the block level. Transfers, delegations, reward withdrawals, IBC packet receipts, and fee payments all show up this way. Indexing Co ingests Hub blocks with their transaction results and events, lets you flatten them with your own transform, and delivers the rows to your PostgreSQL, warehouse, or webhook. See how the project describes the Hub at hub.cosmos.network.

Source CometBFT blocks

Ingest blocks + tx results

Decode ABCI events

Transform your JavaScript

Deliver your database

Why Cosmos Hub data is hard

Events, Not Logs Hub activity is recorded as ABCI events with string attributes, not ABI-encoded logs. A single transaction emits a stack of them, from fee payment through coin_spent, coin_received, and transfer to the module-specific event, and you have to group them back into something meaningful.

Two Places to Look Some events belong to transactions and live in the tx results. Others, like minting, validator commission, rewards, and liveness, are emitted at the block level in finalize_block_events. Read only one and your balances and reward history will not reconcile.

IBC Spans Chains An IBC transfer shows up on the Hub as update_client, recv_packet, fungible_token_packet, and write_acknowledgement events, keyed by ports, channels, and packet sequences. Tracking value across the interchain means reading those packet fields correctly, block after block.

Running gaiad Is a Job The DIY route is running gaiad, the Hub node, keeping it in sync across chain upgrades, and pulling block_results over RPC for every height. Full history means archive storage and a backfill job on top of that.

What Indexing Co delivers for Cosmos Hub

The DIY Path

Stand up and maintain the Hub indexing stack yourself.

Run a gaiad full or archive node, or rent CometBFT RPC.
Fetch block and block_results for every height.
Parse tx results, events, and block-level events into tables.
Build backfill, upgrade handling, and real-time delivery from scratch.

Indexing Co

Hub blocks, tx results, and events, shaped by you, delivered to your store.

Transaction results with code, gas wanted, gas used, and events.
Block-level finalize_block_events alongside the raw block.
Lands in your PostgreSQL, BigQuery, warehouse, or webhook.
Real-time delivery plus complete backfilled history. No node to run.

What you can index

Cosmos Hub event type	What it carries
`transfer`, `coin_spent`, `coin_received`	Sender, recipient, and amount for every token movement
`delegate`, `withdraw_rewards`	Delegator, validator, amount, new shares
`recv_packet`, `fungible_token_packet`, `write_acknowledgement`, `update_client`	IBC packet ports, channels, sequence, denom, amount, memo
`message`, `tx`, `fee_pay`, `tip_pay`	Message action and sender, account sequence, fees
`mint`, `commission`, `rewards`, `liveness` (block level)	Inflation and provisions, validator commission and rewards, missed blocks

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 events you care about from the tx results and return rows for your destination.

// Indexing Co transform: flatten Cosmos Hub ABCI events into rows
function transform(block) {
  const results = [];
  const wanted = ['transfer', 'delegate', 'withdraw_rewards', 'fungible_token_packet'];
  const height = Number(block.height);
  const time = block.block?.header?.time;

  (block.txs_results || []).forEach((tx, txIndex) => {
    for (const event of tx.events || []) {
      if (!wanted.includes(event.type)) continue;
      const attrs = {};
      for (const a of event.attributes || []) attrs[a.key] = a.value;
      results.push({
        chain: block._network,
        block: height,
        block_time: time,
        tx_index: txIndex,
        tx_code: tx.code,
        gas_used: Number(tx.gas_used),
        event_type: event.type,
        from: attrs.sender || attrs.delegator,
        to: attrs.recipient || attrs.receiver || attrs.validator,
        amount: attrs.amount,
        denom: attrs.denom,
      });
    }
  });
  return results;
}

Cosmos Hub with Indexing Co

Run it yourself if

You want full control of Hub infrastructure and have the team to operate gaiad through chain upgrades, pull block_results for every height, and build backfill and delivery in-house.

Use Indexing Co if

You want Hub transfers, staking, IBC, and block-level events delivered to your own database, shaped by your transform, with real-time plus complete history and no node to run.

Get a Demo Open the Console

FAQ

Do I need to run a Cosmos Hub node?

No. Indexing Co sources Hub blocks and transaction results for you, including history, so you do not operate gaiad or an archive node.

What does a Cosmos Hub block look like in Indexing Co?

Each block includes the raw CometBFT block, txs_results with code, log, gas_wanted, gas_used, and events per transaction, plus finalize_block_events for block-level activity. Your transform reads those fields directly.

Can I track IBC transfers?

Yes, on the Hub side. IBC receipts arrive as recv_packet and fungible_token_packet events with channel, port, sequence, denom, amount, and memo attributes, which you can filter and flatten in your transform.

Does Indexing Co decode protobuf transaction messages?

The pipeline delivers ABCI events and their attributes, which is where the Hub records what each message did. The message action itself is available through the message event's action attribute.

Where does the Cosmos Hub 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 the Cosmos Hub in minutes. Set up your first transfers, staking, or IBC pipeline without running a node.