ERC token metadata, balances, transfer history, and NFT ownership are now available through a single, familiar GraphQL endpoint that updates in real time. Hgraph makes querying ERC token data from the Hedera mirror node just as easy as querying HTS token data.

Developers on Hedera have asked for a faster path to real ERC data, without stitching logs, juggling endpoints, or worrying about synthetic HTS events. Today we're launching Hgraph's ERC Indexer: a single GraphQL surface that gives you wallet portfolios, holders, transfer history, and NFT owners & tokenURI with straightforward queries.

It targets pure ERC-20, ERC-721, and ERC-1400 contracts deployed to Hedera's EVM (not HTS facades), and ships with pre-modeled entities, aggregates, and reliability signals so you can ship in minutes. The indexer fits seamlessly amongst the full scope of mirror node data that Hgraph hosts on its bare metal infrastructure. Query ERC and HTS token data from a single endpoint.

Try it now: create an Hgraph account, get an API key and point your app (or the playground) to our mainnet or testnet GraphQL endpoints. Available on Startup plans and above. All details in our documentation.

Viewing WETH (ERC-20) token data in Hgraph’s query playground.

Quick TL;DR

Hgraph's ERC indexing Service continuously discovers ERC contracts on Hedera's EVM, fetches current balances via RPC balanceOf() calls, extracts standard ERC metadata, and exposes a GraphQL schema purpose-built for ERC analytics:

erc_token — token/collection metadata & stats
erc_token_account — per-account balances / NFT counts
erc_nft — per-NFT rows with owner + metadata (tokenURI)
erc_token_transfer — ERC-20/ERC-1400 transfer history
erc_nft_transfer — ERC-721 transfer history

You'll also see metadata_reliability_score (a score of 0 to 1) and processing_timestamp to judge data quality and freshness (details in our documentation). Endpoints require an API key.

Why "pure ERC"? Mirror nodes can surface synthetic ERC-like logs for HTS operations. Great for HTS analytics, but mixing them into ERC analyses can mislead. The ERC Indexer excludes HTS by design so your ERC queries stay "correct by default."

What You Can Do

Holders & top holders — aggregate erc_token_account by token_id (distinct count + ordered list).
Wallet portfolios — list balances for account_id, then join token details for names/symbols/decimals.
NFT ownership & metadata — fetch owner and tokenURI from erc_nft via (token_id, serial_number).
Transfer history — trace token movements over time with sender, receiver, amount, and transfer type (transfer, mint, burn, plus ERC-1400 partition variants).
Security tokens — ERC-1400 support with partition-aware transfers for compliance use cases.

All of these are detailed in the documentation with copy-paste queries and variables. You’ll notice that the ERC token tables and fields share the same naming conventions as HTS token tables and fields.

Quick Start

Get an API key: (Startup plan or higher) and open the GraphQL playground.
Try a query: see our examples here in our docs (e.g., "Token Deep Dive" for holders + aggregates).

…and ship! Add the endpoint and x-api-key header to your app.

How it Works

Under the hood, the indexer discovers contracts that emit Transfer, calls standard ERC views (name, symbol, decimals, etc.), fetches current balances via RPC, indexes transfer events, tracks ERC-721 ownership & tokenURI, and serves it all via GraphQL. We normalize account/address formats (Hedera IDs, long-zero aliases, EVM aliases, hollow accounts) so you don't have to.

Event detection detail: ERC-20 transfers keep the amount in event data, while ERC-721 transfers index the tokenId. Both share the standard Transfer(address,address,uint256) topic hash. ERC-1400 security tokens are detected via isIssuable() and isControllable() probes.

Full schema overview →

Hgraph vs DIY (Mirror Node + JSON-RPC)

For teams already using Hgraph's GraphQL API, this new ERC token data is available through your existing endpoint. Everything you need, out of the box.

If you prefer to build everything yourself, a REST API and JSON-RPC Relay give you the building blocks: logs endpoints, read-only calls, and standard EVM JSON-RPC like eth_getLogs.

ERC Data Aspect	Hgraph API	DIY
Endpoint footprint	One	Multiple
Pre-modeled entities	5 tables	None
Holders (distinct & list)	Built-in	DIY
Portfolio (per-account balances)	Built-in	Logs
Transfer history	Built-in	DIY aggregation
NFT owner & tokenURI	One-query	Multi-step
Aggregates (count/sum/avg/max)	Built-in	None
Event/type detection	Auto	Manual
Address/account resolution	Auto	Manual
ERC-1400 security tokens	Yes	Manual detection
Metadata quality score	Yes	No
Freshness field	Yes	No
HTS synthetic logs mixed-in	Avoided	Possible
JSON-RPC required	No	Yes
Setup effort	Minutes	Weeks

Query Example

Hgraph GraphQL API: one request with token details, holder stats, top holders, and recent transfers.

View all query examples →

query TokenDeepDive($tokenId: bigint!) {
  token: erc_token_by_pk(token_id: $tokenId) {
    token_id
    token_evm_address
    contract_type
    name
    symbol
    decimals
    total_supply
    metadata_reliability_score
    transfers_indexed_timestamp
  }
  holder_stats: erc_token_account_aggregate(
    where: { token_id: { _eq: $tokenId }, balance: { _gt: "0" } }
  ) {
    aggregate {
      count
      sum { balance }
      max { balance }
    }
  }
  top_holders: erc_token_account(
    where: { token_id: { _eq: $tokenId }, balance: { _gt: "0" } }
    order_by: { balance: desc }
    limit: 10
  ) {
    account_id
    balance
  }
  recent_transfers: erc_token_transfer(
    where: { token_id: { _eq: $tokenId } }
    order_by: { consensus_timestamp: desc }
    limit: 5
  ) {
    sender_account_id
    receiver_account_id
    amount
    transfer_type
  }
}

# Variables (WETH): { "tokenId": 9470869 }

Try it in our account dashboard →

Alternate: DIY (conceptual): pull Transfer logs across history and aggregate distinct holders; use eth_getLogs via JSON-RPC and do the same. Use Mirror Node smart-contract logs endpoints, window by block/time, and paginate. For transfer history, store and index events yourself.

Pitfalls Avoided with Hgraph’s Indexer

HTS synthetic logs mixed into ERC analytics — our pure-ERC dataset excludes them by design.
Address/alias fragmentation — we resolve Hedera IDs, long-zero, and EVM aliases automatically.
Big integers & decimals — balances and supplies are returned as strings with full precision.

Rebasing token drift — RPC-based balanceOf() fetching ensures accurate balances for aTokens and other rebasing tokens where event-based calculation fails.

Read documentation →

Hgraph’s goal is to make it as easy to query ERC token data on the network as it is to query native HTS token data. It should be familiar for EVM and Hedera developers alike and act as a natural extension to make the full spectrum of data on Hedera available to anyone.

Our bespoke ERC Token Indexing service was built with feedback and guidance from our users, customers, partners and EVM experts. Our hope is to remove blockers in the ecosystem to help accelerate development and growth of Hedera and beyond.

Quick Links

What's Next?

We are reviewing community feedback , making plans to support additional ERC standards and developing new ecosystem metrics to create full visibility into Hedera’s EVM activity. If there's a query you want built in, tell us, we'll add it to the examples.

Start building: grab your API key and run your first holders query in the playground.

Announcing Hgraph's ERC Token Data Indexer for Hedera