Blockchain Indexing
Queryable APIs over live chain data.
Custom on-chain data indexers for EVM and non-EVM chains — from event logs to production GraphQL APIs.
On-chain data is publicly available but not queryable at the resolution your application needs. Block explorers show you transactions; they do not give you aggregated protocol metrics, user position histories, or cross-contract event streams shaped to your specific data model. We build the indexing infrastructure that does — custom, production-grade, and built to stay in sync.
What we build
The right indexing stack depends on your chain, your data model, your latency requirements, and whether you need decentralized or self-hosted infrastructure. We select and implement the appropriate tooling for your specific situation.
Custom Subgraphs (The Graph)
We write custom subgraphs for The Graph Protocol — defining the event handlers, entity schemas, and derived mappings that transform raw EVM events into a GraphQL API your application can query. We handle the full lifecycle: schema design, handler implementation, deployment to the hosted service or decentralized network, and indexing optimization for subgraphs that need to process large historical datasets efficiently.
Ponder and Envio Indexers
For teams that need self-hosted indexing with a modern developer experience, we build on Ponder — a TypeScript-native framework with real-time indexing, automatic re-indexing on schema changes, and a built-in GraphQL API server. For ultra-low-latency indexing requirements, we use Envio's HyperSync infrastructure, which delivers significantly faster historical sync than standard RPC-based approaches. We select the framework based on your specific latency, cost, and operational requirements.
EVM Event Indexing
We index events across EVM-compatible chains — Ethereum, Polygon, Arbitrum, Optimism, Base, and others — designing event handlers that capture the on-chain data your application needs and transform it into queryable, relational structures. For protocols with complex event interdependencies — where the meaning of one event depends on the state established by previous events — we design stateful handlers that maintain the derived state correctly across re-orgs and chain resets.
Non-EVM Chain Support
Not every protocol lives on an EVM chain. We have built indexing infrastructure for Solana, Filecoin, and other non-EVM chains where the account model, transaction structure, and event system differ fundamentally from the EVM. Our Protocol Labs background means non-EVM infrastructure is not foreign territory — it is where we spent years.
Real-Time and Historical Indexing
Production indexers need to do two things: catch up to the current chain tip from genesis or a specified block range, and then stay in sync as new blocks arrive. We design indexers that handle both efficiently — optimized historical backfill that does not overwhelm your RPC provider, and real-time processing that keeps latency to new blocks low enough for your use case.
REST and GraphQL APIs Over Chain Data
We expose indexed data through the API layer your application needs — GraphQL for flexible querying from frontend applications, REST for simpler consumption patterns and third-party integrations. API design includes authentication, rate limiting, caching, and pagination for large datasets, so the indexer serves as a reliable data layer your application can depend on.
Multi-Chain Aggregation
For protocols deployed across multiple chains, we build unified indexing infrastructure that aggregates data from each chain into a single queryable layer. Users and applications see protocol-level data — total TVL, user positions, historical activity — without needing to query each chain separately and reconcile the results.
Chains & Networks We Index
We index across EVM and non-EVM chains. The indexing architecture varies by chain — account model, transaction structure, event system, and finality characteristics all affect how an indexer is designed and operated.
EVM-Compatible
Ethereum, Polygon, Arbitrum, Optimism, Base, Avalanche, BSC — and any EVM-compatible chain that follows the standard account and event model. We design event handlers for complex stateful protocols, including re-org handling, upgradeable proxy patterns, and multi-contract event interdependencies.
Non-EVM
Solana, Filecoin, Flow — chains with fundamentally different account models, transaction formats, and instruction structures. Our Protocol Labs background means non-EVM infrastructure is not unfamiliar territory. We have built and operated production indexers for these chains.
L2 & Appchains
Any EVM-compatible L2 or custom appchain — including chains built on the OP Stack, Arbitrum Orbit, or Polygon CDK. We handle the chain-specific finality characteristics, sequencer behavior, and bridge event structures that appchain indexing requires.
Our Indexing Stack
We are not tied to a single indexing framework. The right tool depends on your chain, your latency requirements, your cost constraints, and whether you need decentralized or self-hosted infrastructure.
The Graph Protocol
Subgraph development for both the hosted service and the decentralized network. We write schema definitions, event handler mappings, and derived entity logic — and we optimize for indexing performance on subgraphs that need to process large historical event sets efficiently.
Ponder
TypeScript-native, local-first indexing with real-time event processing, automatic re-indexing on schema changes, and a built-in GraphQL API server. Best for teams that want modern developer ergonomics and full control over their indexing infrastructure without deploying to The Graph network.
Envio
High-performance EVM indexing via HyperSync — significantly faster historical backfill than standard RPC-based approaches. Best for protocols that need to index large historical datasets quickly or have low-latency real-time requirements.
Custom Indexers
Go, Rust, and TypeScript indexers for non-standard chains, high-throughput requirements, or protocol-specific logic that generic frameworks cannot express. GraphQL and REST API layers over PostgreSQL and TimescaleDB for indexed data storage and time-series queries.
How We Build It
Blockchain indexers fail in predictable ways: incomplete edge case handling at schema design time, re-org bugs that corrupt historical data, and backfill strategies that cannot keep up with chain history. We design to avoid all three.
1. Chain & Event Analysis
We map every contract and event to index, define the data model, and identify the edge cases that trip up naive indexers — re-organizations, failed transactions, upgradeable proxy patterns, and multi-step event sequences where intermediate state matters. This analysis happens before any code is written.
2. Schema & API Design
We design the GraphQL or REST API schema before writing the indexer, so the API surface is correct from day one. Changing an API schema after consumers are built is expensive. Getting it right at design time — by working backward from how the data will be queried — avoids that cost.
3. Indexer Development & Backfill
We write the indexer, run the historical backfill, and validate indexed data against on-chain state. Validation is not optional — an indexer that appears to work but silently misses events or derives incorrect state is worse than no indexer at all.
4. Production Deployment & Monitoring
We deploy with re-org handling, indexing lag monitoring, and alerting configured. You get an indexer that keeps up with the chain in real time and alerts when it does not — not one that silently falls behind. Every production deployment includes documentation on operational procedures and common failure modes.
Who needs blockchain indexing
Any blockchain product that needs to display, analyze, or act on on-chain data at a resolution that block explorers and raw RPC calls cannot provide efficiently.
TVL tracking, user position histories, liquidation event feeds, yield calculations, and protocol health metrics — all requiring efficient indexing of high-volume on-chain events across multiple contract addresses.
Ownership history, transfer events, marketplace activity, trait rarity rankings, and collection-level analytics — requiring indexing of ERC-721 and ERC-1155 events with metadata resolution.
Governance proposal lifecycle tracking, voting history, treasury movements, and delegate activity — the on-chain record of organizational decision-making that DAO dashboards and analytics tools depend on.
Research and analytics platforms that need deep historical chain data in queryable form — user behavior analysis, protocol comparison, market microstructure research, and ecosystem health monitoring.
Regulatory compliance tools that need complete, auditable records of on-chain activity — transaction histories, counterparty identification, and activity timelines for AML and reporting purposes.
Why AR Data
Our blockchain indexing work is backed by direct Protocol Labs experience — years spent building and operating decentralized infrastructure at production scale on the Filecoin and IPFS networks. That is not a talking point; it is the difference between someone who has configured a subgraph for a tutorial project and someone who has debugged chain re-org handling in a production indexer serving live users.
We combine that on-chain depth with the smart contract expertise needed to design indexing schemas that accurately model your protocol's behavior — including the edge cases and contract upgrade paths that naive indexers miss. And we bring the enterprise delivery standards from our broader background to ensure that what we build is observable, maintainable, and documented.
We use agentic workflows in our own build process. We deliver faster than a traditional development shop without reducing the quality of what we ship.
Ready to build a blockchain indexer?
30 minutes. We scope the chain, the contracts, the data model, and the API layer. No pitch deck.
