Aptos Data: Index Move Events, Resources, and Transactions

Index Aptos by consuming the Transaction Stream, decoding Move modules, events, and account resources, and delivering them to your own database. Real-time and complete history, no Aptos indexer to operate.

Aptos is a non-EVM chain built in Move, and its data model is unlike anything on an EVM chain. State is not held in per-contract storage. It lives as strongly-typed resources stored directly under accounts, addressable by a full path like 0x1::coin::CoinStore, and modules emit events as a separate stream alongside each transaction. Aptos now has two event forms running in parallel: modern module events tagged with #[event], and the deprecated EventHandle events inherited from Diem that will never fully disappear from history. Indexing the chain means understanding both, plus the resource layout the events describe.

The official path is the Transaction Stream Service, a gRPC stream of typed transactions, feeding processors that write product tables in Postgres behind the Aptos Indexer GraphQL API. Running that stack yourself means a full node synced from genesis, a GrpcManager, DataService, and Rust processors. Indexing Co consumes the Transaction Stream for you, decodes Move modules, events, and resources, runs your TypeScript transform, and lands the result in your own database. Real-time and full history, with no Aptos-specific indexer to operate.

Source Transaction Stream

Ingest transactions

Decode Move events, resources

Transform your TypeScript

Deliver your database

Why Aptos data is hard

The Resource Model State is not in per-contract storage. It is typed Move structs with the key ability, stored under accounts and addressable by a path like 0x1::coin::CoinStore. Reconstructing meaningful state means tracking resource writes per account, not reading a contract's storage slots.

Two Kinds of Move Events Aptos runs module events (#[event] structs, framework 1.7+) alongside the deprecated EventHandle events from Diem, each identified by a GUID and sequence number. Both still appear in history, and the legacy ones can be unreadable when not a top-level field. You have to handle both forms correctly.

The Transaction Stream Is DIY The official source is a gRPC Transaction Stream feeding Rust processors. Self-hosting it means a full node synced from genesis, a GrpcManager and DataService, and Postgres processors written in the Indexer SDK. That is an entire stack to run before you have a single row.

Sparse Third-Party Tooling Per-chain Aptos coverage is mostly Aptos Labs' own hosted endpoint and GraphQL API. There is little independent indexing infrastructure to fall back on, so when the opinionated GraphQL tables do not match your shape, you are building from the raw stream yourself.

What Indexing Co delivers for Aptos

The DIY Path

Stand up and operate the official indexer stack yourself.

Run an indexer full node synced from genesis.
Operate a GrpcManager, DataService, and file store.
Write Rust processors against the Transaction Stream SDK.
Decode Move resources and both event forms, then build backfill and delivery.

Indexing Co

One pipeline off the Transaction Stream, delivered to your store.

We consume the Transaction Stream for you, no node to run.
Move modules, events, and resources decoded for you.
Shaped by your TypeScript transform, not Rust processors.
Lands in your PostgreSQL, BigQuery, warehouse, or webhook, real-time plus complete history.

What you can index

Move Data	Account and Transaction Data
Module events (#[event] structs)	Account resource writes
Legacy EventHandle events	Resource state by typed path
Decoded Move function calls	Transactions, versions, and timestamps
Object model events and ObjectCore	Coin and fungible asset balances

A transform, not a subgraph

You write the indexing logic in TypeScript, not Rust processors or AssemblyScript, and change it without re-syncing the chain from genesis. The example below shapes a decoded Aptos coin-deposit module event into a row for your database.

// Illustrative: shape a decoded Aptos Move event into an output row
export function onDepositEvent(event: MoveEvent): DepositRow {
  return {
    version: event.transactionVersion,
    timestamp: event.blockTimestamp,
    eventType: event.type,          // e.g. 0x1::coin::DepositEvent
    account: event.accountAddress,
    coinType: event.data.coin_type,
    amount: event.data.amount,
  };
}

Aptos with Indexing Co

Run it yourself if

You want to operate the full indexer stack, from a genesis-synced node through GrpcManager and Rust processors, and have the team to maintain it.

Use Indexing Co if

You want Move events, resources, and transactions decoded off the Transaction Stream and delivered to your own database, with real-time plus complete history and no indexer to run.

FAQ

Do I need to run the Aptos indexer stack myself?

No. Indexing Co consumes the Transaction Stream for you, so you do not run a genesis-synced full node, a GrpcManager, a DataService, or Rust processors. You define the output and we deliver it.

Does Indexing Co handle both module events and EventHandle events?

Yes. Both the modern module events (#[event] structs) and the deprecated EventHandle events from Diem appear in Aptos history. We decode both forms so your dataset is complete across the chain's lifetime.

Can I index account resources, not just events?

Yes. Aptos state lives as typed resources under accounts. We decode resource writes by their full Move path so you can track state, not only the events that describe changes to it.

How is this different from the Aptos GraphQL API?

The hosted GraphQL API exposes opinionated product tables shaped by Aptos Labs. Indexing Co shapes the data with your TypeScript transform into your own schema, in your own database, instead of querying someone else's tables.

Can I get complete historical Aptos data?

Yes. We backfill from your chosen start version and merge it with real-time stream data, so your dataset is gap-free without you reconstructing history from the archive.

Get Started

Index Aptos in minutes. Consume the Transaction Stream, decode Move events and resources, and deliver to your own database without running a node.

Get a Demo | Open the Console