Tonscan and TON Scanner — Overview of Tools for the TON Blockchain

Over the past two years, the TON blockchain (The Open Network) has transformed from a niche project into one of the fastest-growing ecosystems in the crypto industry. Millions of Telegram users interact daily with TON wallets, NFT collections, and DeFi protocols. But to fully work with any blockchain, you need a reliable transaction viewing tool — a blockchain explorer. This is where Tonscan and a whole range of TON scanner solutions come into play, allowing you to track any activity on the network.

In this article, we will explore how the TON blockchain works, what capabilities tonscan and alternative scanners provide, how developers can use the TON API, and why having your own RPC infrastructure is critically important for serious projects.

What Is the TON Blockchain

TON (The Open Network) is a blockchain platform originally developed by the Telegram team. After legal proceedings with the SEC, the project was handed over to the community and is now being developed by independent developers with support from the TON Foundation. Despite the formal separation from Telegram, integration with the messenger remains a key competitive advantage: the TON Space wallet is built right into the app, and mini-applications (Telegram Mini Apps) run on TON.

Architecturally, TON is fundamentally different from most blockchains. The network uses a multi-chain structure: there is a masterchain that coordinates the operation of multiple workchains. Each workchain, in turn, can be split into shardchains for load processing. This approach provides a theoretical throughput of millions of transactions per second, although in practice the network processes tens of thousands of TPS — which still significantly exceeds Ethereum and most L2 solutions.

For the Russian-speaking audience, TON holds special significance. Telegram is the most popular messenger in Russia and CIS countries, meaning this audience is the first to gain access to new ecosystem features. When you send TON coins through the @wallet bot on Telegram, a full-fledged blockchain transaction happens behind the scenes, which can be tracked via ton scan.

Key technical characteristics of TON:

• Consensus: Byzantine Fault Tolerant Proof-of-Stake (BFT PoS) with validators
• Smart contracts: FunC language (low-level) and Tact (high-level), compiled to TVM bytecode
• Addressing: two formats — raw (workchain:hex) and user-friendly (base64 with checksum)
• Block time: approximately 5 seconds on the masterchain
• Transaction costs: fractions of a cent, gas payment model via Toncoin

It is precisely the complex multi-chain architecture that makes tools like tonscan especially important: without a scanner, making sense of the data flow between shards is virtually impossible.

Tonscan — Feature Overview

Tonscan (tonscan.org) is the main blockchain explorer for the TON network, serving the same role that Etherscan does for Ethereum. The tool allows you to explore any data recorded on the blockchain through a convenient web interface.

Transaction Search and Viewing

The main function of any ton scan is searching by transaction hash, wallet address, or block number. Tonscan displays full information about each transaction:

• Sender and recipient (with user-friendly address decoding)
• Transfer amount in Toncoin and current dollar equivalent
• Network fees (gas fees)
• Confirmation status
• Messages exchanged between smart contracts
• Logical time — a unique identifier for the order of operations in TON

Wallet Analysis

When you enter a wallet address in tonscan, you get detailed information: balance in TON and Jetton standard tokens, full transaction history, list of owned NFTs, and interactions with smart contracts. For contract addresses, the contract type is displayed (wallet v3r2, wallet v4r2, and other versions), as well as the status — active, uninit, or frozen.

Smart Contract Viewing

Tonscan allows you to view the code and data of smart contracts deployed on the TON network. For verified contracts, the source code in FunC or Tact is available, along with the list of methods and their calls. This feature is critically important for auditing DeFi protocols and verifying project reliability.

Network Statistics

In the statistics section, ton scan provides macro data: total number of accounts, transaction volume over a period, validator activity, current staking APY, gas fee distribution, and other network health metrics.

Jetton Tokens and NFTs

Separate sections of tonscan are dedicated to Jetton tokens (the TON equivalent of ERC-20) and NFT collections. For each token, the total supply, number of holders, history of large transfers, and master contract address are displayed. For NFTs — metadata, ownership history, and current market value.

Besides tonscan.org, there are alternative TON scanner solutions: Tonviewer (tonviewer.com) from the Tonkeeper team with a more modern interface, TON Explorer from the TON Foundation, and ton.cx — a minimalist and fast explorer. Each of them retrieves data from the blockchain via the TON API or their own full nodes.

TON API for Developers

The visual interface of tonscan is convenient for manual searching, but developers need programmatic access to blockchain data. Several levels of TON API exist for this purpose.

TON HTTP API (toncenter)

The Toncenter API is a RESTful interface providing access to TON blockchain data via HTTP requests. Main endpoints:

GET /api/v2/getAddressInformation?address=EQ...
GET /api/v2/getTransactions?address=EQ...&limit=10
GET /api/v2/getBlockHeader?workchain=0&shard=...&seqno=...
POST /api/v2/sendBoc  (sending a transaction)

The free toncenter tier is limited to one request per second — sufficient for testing but completely inadequate for production applications. For serious projects, you need your own API key or a dedicated RPC endpoint.

TON ADNL (Native Protocol)

ADNL (Abstract Datagram Network Layer) is the native network protocol of TON, providing direct interaction with nodes. Through ADNL, you can execute smart contract get-methods, subscribe to block updates, and receive data with minimal latency. Libraries such as tonutils-go (Go) and pytoniq (Python) work through this protocol.

Practical Example: Monitoring Incoming Transfers

Let's say you are developing a payment gateway and want to track incoming Toncoin transactions via the ton scan API:

import requests
import time

WATCHED_ADDRESS = "EQD..."  # your address
API_URL = "https://your-rpc.settla.net/api/v2"  # RPC endpoint
last_lt = 0

while True:
    resp = requests.get(f"{API_URL}/getTransactions", params={
        "address": WATCHED_ADDRESS,
        "limit": 20,
        "archival": "true"
    })
    txs = resp.json()["result"]

    for tx in txs:
        lt = int(tx["transaction_id"]["lt"])
        if lt <= last_lt:
            continue

        in_msg = tx.get("in_msg", {})
        value = int(in_msg.get("value", 0)) / 1e9  # nanoTON -> TON

        if value > 0:
            sender = in_msg.get("source", "unknown")
            print(f"Incoming: {value} TON from {sender}")
            # Payment processing logic here

        last_lt = max(last_lt, lt)

    time.sleep(5)

In this example, we use a dedicated RPC endpoint instead of the public toncenter, which guarantees stable operation without rate limiting. This approach is used when integrating TON payments into bots, marketplaces, and games.

Indexers: TON Index and dTON

For complex analytical queries (for example, "all transactions of address X over the last month" or "top 100 holders of token Y"), a single RPC is not enough. Indexers such as TON Index and dTON collect data from the blockchain into an SQL database and provide an extended API with filtering, pagination, and aggregation. It is indexers that supply data to tonscan and other explorer interfaces.

TON Address Monitoring

Tracking activity on specific addresses is one of the most in-demand tasks when working with TON. Use cases range from personal wallet monitoring to corporate compliance monitoring.

Why Monitoring Is Needed

• Wallet security: instant notification of any outgoing transactions allows for quick response to key compromise
• Payment systems: automatic confirmation of incoming payments in bots and services
• DeFi analytics: tracking large token movements (whale tracking) for trading strategies
• Compliance and AML: monitoring interactions with flagged addresses to meet regulatory requirements

Monitoring Tools

Tonapi Streaming — WebSocket subscription to events by address. Allows receiving real-time notifications without polling. However, public endpoints have limits on the number of subscriptions.

Your own full node — the most reliable option. A TON full node indexes all blocks and allows you to set up custom filtering logic. Deploying and maintaining a node requires significant resources: at least 16 GB RAM, a fast NVMe disk, and a stable connection.

Webhook services — an intermediate option where a third-party provider monitors specified addresses and sends an HTTP callback when activity is detected. Convenient for integration with existing infrastructure.

Example Alert Setup

A typical TON address monitoring workflow looks like this:

1. Register the address in the monitoring system
2. The service subscribes to updates via an RPC node or indexer
3. When a new transaction is detected — parse the data (amount, sender, operation type)
4. Send a notification via Telegram bot, email, or webhook
5. Log the event for subsequent analysis

For steps 2-3, the stability of the RPC connection is critically important. If the node is unavailable when a new block appears, the transaction will be detected with a delay or missed entirely. This is exactly why professional monitoring solutions use multiple RPC providers with automatic failover.

Data obtained during monitoring can be verified through tonscan — simply open the transaction hash in the explorer to confirm the parsing is correct. Ton scan serves as the reference standard for verification.

TON RPC via Settla

All the scenarios described above — from working with tonscan-like tools to address monitoring and running DeFi bots — come down to one bottleneck: reliable access to a TON node. Public endpoints are suitable for experiments but not for production.

Problems with Public RPCs

Anyone who has worked with public TON nodes knows their limitations:

• Rate limiting: 1-10 requests per second on free tiers
• Instability: public nodes can become overloaded, especially during periods of heightened network activity (NFT mints, new DeFi protocol launches)
• Latency: geographically distant nodes add latency, which is critical for arbitrage bots
• No archival data: many public endpoints only store recent blocks

What Settla Offers

Settla (settla.net) is a blockchain infrastructure provider offering dedicated RPC endpoints for TON and other networks. Advantages of a dedicated RPC:

• Dedicated resources: your requests don't compete with thousands of other users
• Archival nodes: access to the complete blockchain history, including the earliest blocks — essential for deep analytics and auditing
• Geographic proximity: servers in multiple regions, including locations with minimal ping for Russian-speaking users
• SLA and support: guaranteed uptime and technical support, unlike community nodes
• Compatibility: full compatibility with the toncenter API, meaning switching from the public endpoint is as simple as replacing the URL

How to Connect

Switching from the public toncenter to Settla RPC comes down to replacing the base URL in your application's configuration:

// Before (public endpoint):
const endpoint = "https://toncenter.com/api/v2";

// After (Settla RPC):
const endpoint = "https://ton-rpc.settla.net/api/v2";

// The rest of the code stays the same — the API is fully compatible
const response = await fetch(`${endpoint}/getAddressInformation?address=${addr}`);

For projects using the TON SDK (ton, tonweb, tonutils), you simply need to pass the new endpoint when initializing the client. No other code changes are required.

Who Needs a Dedicated RPC

• Payment gateways: processing incoming transactions without losses or delays
• DeFi protocols: interacting with smart contracts with guaranteed transaction delivery
• Analytics platforms: bulk data extraction without rate limit restrictions
• NFT marketplaces: real-time collection and metadata indexing
• Trading bots: minimal latency for sending and tracking transactions
• Developers: a stable environment for testing and debugging smart contracts

Comparison of TON Explorers

Several TON scanner tools exist on the market, each with its own strengths. Understanding the differences will help you choose the optimal option for your needs.

Tonscan remains the most complete solution with the maximum volume of data. Tonviewer wins in interface convenience and display speed. For quickly checking a transaction hash, ton.cx is the fastest option.

It's important to understand that all these ton scan tools are frontends that visualize data obtained from the blockchain via RPC nodes and indexers. The quality and speed of an explorer directly depend on the infrastructure it runs on.

Security and Best Practices for Working with TON

When working with the TON blockchain and ton scan tools, it's important to follow basic security rules.

Transaction Verification

Always verify transactions through multiple independent sources. If tonscan shows one set of data and an alternative explorer shows another, that's a reason to investigate. In practice, discrepancies are extremely rare and usually related to indexing delays, but the habit of cross-checking will protect you from fraud.

Addresses and Formats

TON uses two address formats: raw and user-friendly. The same wallet can be displayed as 0:abcd...1234 (raw) or EQCr...ZxY (user-friendly, bounceable) and UQCr...ZxY (user-friendly, non-bounceable). Tonscan understands all formats, but when integrating into code, make sure you use the correct type: bounceable for smart contracts, non-bounceable for regular transfers.

Private Key Storage

An RPC endpoint, whether the public toncenter or a dedicated Settla endpoint, should never have access to your private keys. Transaction signing should always happen on the client side, and only the already-signed BOC (Bag of Cells) is sent to the RPC. This is a fundamental principle: ton scan and RPC providers work only with public blockchain data.

Monitoring Your Own Infrastructure

If you use a dedicated RPC endpoint for critical operations, set up monitoring for its availability. Check response times, synchronization with the latest network block, and response correctness. Providers like Settla offer monitoring dashboards, but additional external monitoring never hurts.

Conclusion

The TON ecosystem continues to grow, and tools for working with the blockchain are becoming increasingly mature. Tonscan and other TON scanner solutions ensure network transparency, allowing any participant to verify any transaction or smart contract. For developers, the TON API opens up possibilities for building complex applications — from payment gateways to analytics platforms.

The key takeaway: the reliability of your product is determined by the reliability of the infrastructure it runs on. Public endpoints are a good entry point, but for production workloads, you need a dedicated RPC with a guaranteed SLA. Settla provides exactly this kind of infrastructure for TON and other blockchains, allowing you to focus on product development rather than node maintenance.

Regardless of whether you use ton scan for manually checking a transaction or building an automated monitoring system, understanding the architecture of TON and the available tools is the foundation for effective work with this blockchain.