Starknet Data: Index Cairo Events, Transactions, and Receipts

Index Starknet events, transactions, and receipts in one pipeline, delivered to your own database. Raw Cairo felts and execution status per transaction, no full node to run.

Starknet is a validity rollup on Ethereum. It uses STARK proofs to validate execution off chain, runs contracts written in Cairo rather than Solidity, and has native account abstraction, so every account is a smart contract account. None of that is EVM: there are no ABI-encoded logs, addresses are field elements, and every value on chain is a felt. You can read how the team frames it at starknet.io.

That is the data problem. Starknet events carry a contract address, a list of keys, and a list of data felts, and turning them into rows means knowing each contract's Cairo event layout. Indexing Co delivers Starknet blocks with each transaction's receipt attached, runs your transform over them server-side, and lands the rows in your own PostgreSQL, warehouse, or webhook. Real-time, with no full node to operate.

Source Starknet L2 blocks

Ingest transactions, receipts

Parse events as felts

Transform your JavaScript

Deliver your database

Why Starknet data is hard

Cairo, Not the EVM Starknet contracts are written in Cairo and emit events as arrays of field elements. EVM ABIs, topic hashes, and log decoders do not apply. Each contract's event layout decides which felts are keys, which are data, and how multi-felt values like u256 are split.

Every Account Is a Contract Native account abstraction means the sender of a transaction is itself a contract, and calldata encodes calls in the account's own format. Attributing activity to users means reading account contracts, not externally owned addresses.

Receipts Carry the Outcome What a transaction did lives in its receipt: execution status, the actual fee and its unit, events, L2 to L1 messages, and execution resources. Reverted transactions still land in blocks, so a dataset without receipts counts work that never happened.

Your Own DB, Not a Hosted API Starknet RPC endpoints and hosted APIs leave you paging through blocks behind rate limits. Powering an app or analytics workload means owning the data in your own store, shaped the way your product queries it.

What Indexing Co delivers for Starknet

The DIY Path

Stand up and maintain the whole stack yourself.

Run a Starknet full node or wire up a third-party RPC.
Fetch blocks, then fetch and join a receipt for every transaction.
Map Cairo event layouts to keys and data felts per contract.
Build backfill, retries, and real-time delivery from scratch.

Indexing Co

One pipeline sources, shapes, and delivers Starknet to your store.

Starknet blocks with every transaction's receipt and events attached.
Shaped by your JavaScript transform into the schema you define.
Lands in your PostgreSQL, BigQuery, warehouse, or webhook.
The same pipeline carries your Ethereum and other L2 data. No node.

What you can index

Starknet data type	For example
Contract events	Event selector, keys, and data felts per emitting contract
Transactions	Type, sender account, nonce, calldata, signature, resource bounds
Receipts	Execution status, actual fee and unit, execution resources
L2 to L1 messages	Messages sent from Starknet contracts to Ethereum
Block metadata	Block number, timestamp, sequencer, gas prices, Starknet version

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. This one returns a row per event, with the raw felts kept so you can decode the contracts you care about.

// Indexing Co transform: one row per Starknet event, raw felts kept as hex strings
function transform(block) {
  const results = [];

  for (const tx of block.transactions || []) {
    const receipt = tx.receipt || {};
    (receipt.events || []).forEach((event, i) => {
      results.push({
        chain: block._network,
        block_number: block.block_number,
        timestamp: block.timestamp,
        tx_hash: tx.transaction_hash,
        tx_type: tx.type,
        sender: tx.sender_address,
        execution_status: receipt.execution_status,
        event_index: i,
        contract_address: event.from_address,
        selector: event.keys?.[0], // starknet_keccak of the event name
        keys: event.keys,
        data: event.data,
      });
    });
  }
  return results;
}

Starknet with Indexing Co

Run it yourself if

You want full control of node infrastructure and have the team to operate a Starknet full node, join receipts to transactions, and build backfill and delivery in-house.

Use Indexing Co if

You want Starknet events, transactions, and receipts delivered to your own database, on a schema shared with your other chains, with no infrastructure to run.

Get a Demo Open the Console

FAQ

Does Indexing Co decode Starknet events automatically?

No ABI-style decoding is claimed here. Events arrive with from_address, keys, and data as hex felts. The first key is the event selector. Your transform maps the remaining keys and data to fields for the contracts you index.

Are transaction receipts included?

Yes. Each transaction carries its receipt, with execution status, finality status, actual fee, events, L2 to L1 messages, and execution resources.

Can I filter out reverted transactions?

Yes. Check receipt.execution_status in your transform and keep only SUCCEEDED rows, or store reverts separately.

Where does the Starknet 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 Starknet in minutes. Set up your first Starknet event pipeline without running a node.