TON Data: Index Jettons, Messages, and Contracts

Index TON's Jetton transfers, internal messages, and contract events across its sharded masterchain and workchains, decoded and delivered to your own database. Real-time and complete history, no TON node to run.

TON (The Open Network) is not an EVM chain, and that changes how indexing works. TON is built on an actor model where every smart contract is its own account that communicates by passing asynchronous messages, and the chain is sharded: a masterchain coordinates a base workchain that splits into shards dynamically under load. The Jetton token standard (TEP-74) is the clearest example of the difference. There is no single ERC-20 style contract holding everyone's balance. Each holder gets a separate jetton wallet contract, deterministically addressed from their owner address plus the jetton master, and a single transfer is a multi-message exchange between two of those wallet contracts.

That means token balance and transfer indexing on TON works nothing like decoding ERC-20 logs. Indexing Co ingests TON's blocks and messages across the masterchain and its workchain shards, decodes Jetton transfers, internal messages, and contract events, and delivers them in the shape you want to your own PostgreSQL, warehouse, or webhook. Real-time and full history, with no TON-specific stack to run.

Source masterchain + workchains

Ingest blocks + messages

Decode Jettons, messages

Transform your TypeScript

Deliver your database

Why TON data is hard

A Wallet Contract Per Holder Jettons (TEP-74) do not keep balances in one contract. Every holder has a separate jetton wallet contract, deterministically derived from their owner address plus the jetton master. Tracking a token's balances means tracking thousands of individual wallet contracts, not reading one ledger.

Transfers Are Multi-Message A single Jetton transfer is not one event. The sender messages their own jetton wallet, which messages the recipient's jetton wallet, which notifies the recipient's owner. Reconstructing one logical transfer means correlating several internal messages across contracts.

Sharded, Asynchronous Execution TON is a masterchain plus a base workchain that splits into shards dynamically. Contracts are actors that pass async messages instead of making synchronous calls. Assembling a coherent, ordered view of activity across shards is its own problem, with no EVM-style global transaction trace to lean on.

Native Tooling, Not Subgraphs TON's stack is TON-specific: the TonCenter indexed API and the open-source ton-indexer, which read a node's storage and serve SQL. None of it is subgraph-shaped. There is no AssemblyScript manifest to port; you either run that stack yourself or build message decoding from scratch.

What Indexing Co delivers for TON

The DIY Path

Stand up and maintain the whole TON stack yourself.

Run a TON node and the ton-indexer Docker stack, sized for terabytes of NVMe.
Decode Jetton wallet contracts and correlate multi-message transfers.
Track per-holder wallet contracts and resolve them back to owners.
Build backfill, shard-aware ordering, and real-time delivery from scratch.

Indexing Co

One pipeline covers TON, delivered to your store.

Masterchain and workchain shards in a single pipeline.
Decoded Jetton transfers, internal messages, and contract events, shaped by your TypeScript transform.
Lands in your PostgreSQL, BigQuery, warehouse, or webhook.
Real-time delivery plus complete backfilled history. No node, no ton-indexer to operate.

What you can index

Tokens and accounts	Messages and contracts
Jetton transfers (TEP-74)	Internal messages between contracts
Per-holder jetton wallet balances	External in and out messages
Jetton master metadata and supply	Contract deploys and state init
NFT items and collections (TEP-62)	Decoded message opcodes and bodies

A transform, not a subgraph

You write the indexing logic in TypeScript, not AssemblyScript, and change it without re-indexing from block zero. The example below shapes a decoded Jetton transfer message into a row for your database.

// Illustrative: shape a decoded TON Jetton transfer into an output row
export function onJettonTransfer(msg: DecodedMessage): JettonTransferRow {
  return {
    masterchainSeqno: msg.masterchainSeqno,
    timestamp: msg.utime,
    jettonMaster: msg.jettonMaster,
    fromWallet: msg.source,
    toOwner: msg.destinationOwner,
    amount: msg.amount,
    queryId: msg.queryId,
  };
}

TON with Indexing Co

Run it yourself if

You want full control of TON infrastructure and have the team to operate a node, the ton-indexer stack, and your own Jetton message decoding.

Use Indexing Co if

You want Jetton transfers, internal messages, and contract events decoded and delivered to your own database, with real-time plus complete history and no TON stack to run.

FAQ

How does Indexing Co handle TON's per-holder Jetton wallet model?

TON does not store Jetton balances in one contract. Each holder has a separate jetton wallet contract derived from their owner address and the jetton master. We decode those wallet contracts and resolve transfers back to owners, so you get clean per-holder balances and transfers without tracking thousands of wallet contracts yourself.

Can you reconstruct a full Jetton transfer from TON's messages?

Yes. A single Jetton transfer is a chain of internal messages between the sender's wallet, the recipient's wallet, and the recipient's owner. We correlate those messages into one logical transfer record so you do not have to stitch them together downstream.

Do I need to run a TON node or the ton-indexer stack?

No. Indexing Co sources from TON's masterchain and workchain shards, including historical data, so you do not run a node or operate the open-source ton-indexer Docker stack and its terabytes of storage.

Do you index across TON's shards?

Yes. TON splits its base workchain into shards dynamically under load, coordinated by the masterchain. We ingest across that sharded structure and deliver an ordered, coherent view, rather than leaving you to reassemble activity shard by shard.

Where does the TON 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 TON in minutes. Set up your first Jetton, message, or contract pipeline without running a TON node.

Get a Demo | Open the Console