Celestia Data: Index PayForBlobs, Namespaces, and Transfers

Index Celestia PayForBlobs events, blob namespaces and sizes, transfers, and fees, delivered to your own database. Real-time and complete historical data, no node to run.

Celestia is a modular Layer 1 blockchain built with the Cosmos SDK on CometBFT, with data availability at its core. It orders blobs of data and keeps them available, while execution and settlement live on the chains above it. It separates compute from storage, uses data availability sampling so light nodes can verify a block without downloading all of it, and organizes blob data by namespace so each application can fetch and prove only its own data. Its native token is TIA, which pays for blobspace.

That makes Celestia activity different from an EVM chain's. The core action is a PayForBlobs transaction: a signer pays to post one or more blobs into specific namespaces. Indexing Co ingests Celestia blocks with their transaction results and ABCI events, including every PayForBlobs event with its signer, namespaces, and blob sizes, and delivers the rows to your PostgreSQL, warehouse, or webhook. See how the team frames it at celestia.org.

Source Celestia blocks

Ingest blocks + tx results

Decode PayForBlobs events

Transform your JavaScript

Deliver your database

Why Celestia data is hard

Blobspace Is the Product Most Celestia transactions are not swaps or transfers, they are PayForBlobs payments. Understanding who is buying blobspace, for which namespaces, and in what volume means reading celestia.blob.v1.EventPayForBlobs, not token logs.

Namespaces Map to Rollups Each blob is posted into a namespace, and namespaces are how chains built on Celestia keep their data separate. Attributing blob usage to a rollup or app means tracking namespaces and signers over time, block after block.

Events Are JSON-Encoded Typed events like PayForBlobs carry their attribute values as JSON strings: a quoted signer, an array of base64 namespaces, an array of blob sizes. Bank and fee events use plain strings. Your parser has to handle both.

Block-Level Activity Lives Elsewhere Minting, validator commission, rewards, and liveness are emitted in finalize_block_events, not in transaction results. Fee and issuance analytics need both sources lined up per block.

What Indexing Co delivers for Celestia

The DIY Path

Stand up and maintain the Celestia indexing stack yourself.

Run a celestia-app consensus node, or rent CometBFT RPC.
Fetch block and block_results for every height.
Parse PayForBlobs, bank, and block-level events into tables.
Build backfill, upgrade handling, and real-time delivery from scratch.

Indexing Co

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

PayForBlobs events with signer, namespaces, and blob sizes.
Transaction results with fees, gas used, signers, and events.
Lands in your PostgreSQL, BigQuery, warehouse, or webhook.
Real-time delivery plus complete backfilled history. No node to run.

What you can index

Celestia event type	What it carries
`celestia.blob.v1.EventPayForBlobs`	Signer, namespaces, and blob sizes for each blob payment
`tx`	Fee, fee payer, account sequence
`transfer`, `coin_spent`, `coin_received`	Sender, recipient, and TIA amounts
`message`	Message action (for example MsgPayForBlobs), sender, module
`mint`, `commission`, `rewards`, `liveness` (block level)	Inflation rate and provisions, validator commission and rewards, missed blocks

Blob payloads themselves are not part of these events. The pipeline gives you the payment record: who paid, which namespaces, and how many bytes.

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: one row per PayForBlobs event on Celestia
function transform(block) {
  const results = [];
  const height = Number(block.height);
  const time = block.block?.header?.time;

  (block.txs_results || []).forEach((tx, txIndex) => {
    const fee = (tx.events || []).find((e) => e.type === 'tx' && e.attributes?.some((a) => a.key === 'fee'));
    for (const event of tx.events || []) {
      if (event.type !== 'celestia.blob.v1.EventPayForBlobs') 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,
        signer: JSON.parse(attrs.signer),
        namespaces: JSON.parse(attrs.namespaces),
        blob_sizes: JSON.parse(attrs.blob_sizes),
        fee: fee?.attributes.find((a) => a.key === 'fee')?.value,
        gas_used: Number(tx.gas_used),
      });
    }
  });
  return results;
}

Celestia with Indexing Co

Run it yourself if

You want full control of Celestia infrastructure and have the team to operate a consensus node through network upgrades, pull block_results for every height, and build backfill and delivery in-house.

Use Indexing Co if

You want Celestia blob payments, namespaces, transfers, and fees 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 Celestia node?

No. Indexing Co sources Celestia blocks and transaction results for you, including history, so you do not operate a consensus node or RPC endpoint.

Can I see which rollups or apps are posting blobs?

You get the signer and the namespaces for every PayForBlobs event, along with blob sizes and the fee paid. Mapping a namespace or signer to a named rollup is a lookup you maintain in your own tables.

Does Indexing Co deliver the blob data itself?

No. The pipeline delivers the PayForBlobs event, transaction results, and the raw block, not retrieved blob contents. Use it for blobspace usage, payments, and attribution.

What else is in a Celestia block?

Every transaction result includes code, gas_wanted, gas_used, signers, and events. Block-level events like mint, commission, rewards, and liveness arrive in finalize_block_events.

Where does the Celestia 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 Celestia in minutes. Set up your first blobspace or transfers pipeline without running a node.