0G Data: Index Contracts, Tokens, and AI dApps

Index 0G's contract events, token transfers, and decoded transactions in one pipeline, delivered to your own database. Real-time and complete historical data, no node to run.

0G, also known as Zero Gravity, is a modular Layer 1 built for onchain AI. Its EVM-compatible execution layer runs standard Solidity contracts, while decentralized storage and a separate data availability layer carry the heavy datasets that AI agents, inference, and training workloads depend on. The result is a chain where model outputs, agent actions, and the contracts coordinating them all settle onchain. You can read how the team frames it at 0g.ai.

That AI focus is the data problem. Every agent call, token movement, and contract interaction on 0G lands as EVM logs and traces, and the interesting signal sits inside the decoded contract data, not the raw storage blobs. Indexing Co covers 0G in a single pipeline, decodes the chain into the shape you want, and delivers it to your own PostgreSQL, warehouse, or webhook. Real-time and full history, with no node to operate.

Source 0G L1 blocks

Ingest blocks, logs, traces

Decode ABIs to events

Transform your JavaScript

Deliver your database

Why 0G data is hard

AI Workloads, Onchain Signal 0G is built for AI agents, inference, and model markets, so contract activity carries agent registrations, inference receipts, payments, and reward accounting. The datasets live in decentralized storage, but the state you query and bill against lives in EVM logs. Turning that into rows an application can serve is the real work.

Modular Layers to Reconcile 0G splits execution, storage, and data availability into separate layers. A useful dataset ties an onchain event back to the storage or DA reference it points at, so a naive scraper that only reads execution logs misses half the story. You want history that reflects how the layers connect.

Decoding Across Many Contracts A real 0G dataset spans agent frameworks, token contracts, staking and node contracts, and the DeFi primitives arriving alongside them. Each needs its own ABI and event handling, and proxy patterns make the correct ABI a moving target as contracts upgrade.

Your Own DB, Not a Hosted API Generic RPC endpoints and hosted query APIs leave you rate-limited and renting someone else's schema. Powering an AI dApp or analytics workload on 0G means owning the data in your own store, shaped the way your product queries it.

What Indexing Co delivers for 0G

The DIY Path

Stand up and maintain the whole stack yourself.

Run a 0G archive node or wire up a third-party RPC.
Fetch and decode logs, traces, and receipts against the right ABIs.
Track proxy upgrades and per-contract event schemas by hand.
Build backfill, reorg handling, and real-time delivery from scratch.

Indexing Co

One pipeline sources, decodes, and delivers 0G to your store.

0G contract events, token transfers, and decoded txs in a single pipeline.
Decoded data, shaped by your JavaScript transform.
Lands in your PostgreSQL, BigQuery, warehouse, or webhook.
Real-time delivery plus complete backfilled history. No node, no RPC babysitting.

What you can index

EVM data type	On 0G, for example
Contract events and logs	Agent registrations, inference and reward events
Token transfers (ERC-20, ERC-721)	0G token movements, AI dApp asset mints
Decoded transactions and traces	Agent calls, staking and node operations
Protocol and account state	Storage and DA references, staking positions, balances

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: decode the logs you care about and return rows for your destination.

// Indexing Co transform: reshape each block into rows for your database
function transform(block) {
  const results = [];
  const signatures = [
    'event Transfer(address indexed from, address indexed to, uint256 value)'
  ];

  for (const tx of block.transactions || []) {
    for (const log of tx.receipt?.logs || []) {
      const event = utils.evmDecodeLogWithMetadata(log, signatures);
      if (!event) continue;
      results.push({
        chain: block._network,
        block: Number(block.number),
        tx_hash: tx.hash,
        contract_address: log.address?.toLowerCase(),
        from: event.decoded.from,
        to: event.decoded.to,
        value: event.decoded.value,
      });
    }
  }
  return results;
}

0G with Indexing Co

Run it yourself if

You want full control of node infrastructure and have the team to operate a 0G archive node, decode every contract's ABIs, and build backfill and reorg handling in-house.

Use Indexing Co if

You want 0G contract events, token transfers, and decoded transactions delivered to your own database, with real-time plus complete history and no infrastructure to run.

Get a Demo Open the Console

FAQ

Do I need to run a 0G node?

No. Indexing Co sources 0G blocks, logs, and traces for you, including full historical data, so you never operate an archive node or babysit an RPC endpoint.

Can I index any contract on 0G?

Yes. Point a pipeline at any 0G contract or set of contracts, from agent and staking contracts to token and DeFi deployments, and we decode the events against the right ABI.

Does Indexing Co work with 0G's modular storage and data availability?

We index the EVM execution layer: contract events, token transfers, and decoded transactions. That includes the onchain references your contracts emit to storage and DA, so you can join execution data back to the datasets it points at.

Where does the 0G data go?

Into your own destination: PostgreSQL, BigQuery, a warehouse, or a webhook. You define the output schema and own the storage.

Can I get complete historical 0G data?

Yes. We backfill from your chosen start block and merge it with real-time data, so your 0G dataset is gap-free from genesis forward if you want it.

Get Started

Index 0G in minutes. Set up your first 0G contract or token pipeline without running a node.