Public explorers like Etherscan or Solscan are convenient as long as you use public networks and their API covers your tasks. A dedicated blockchain explorer becomes essential when you work with a private or consortium blockchain — there is no public explorer there. Or when you need custom display logic: branded UI, specific protocol metrics, or closed query patterns. We've encountered situations where public services expose confidential traffic data — a custom explorer solves that. An archive node for Ethereum takes about 17 TB, but the cost is justified: you get full control and the ability to customize the interface. Savings on commercial explorer licenses can reach 40% annually.
How to Choose a Platform for a Blockchain Explorer
Blockscout: Universal Solution for EVM
Open-source, written in Elixir/Phoenix, supports all EVM-compatible networks. It is used as the official explorer for Gnosis Chain, Optimism, Base, and other L2s. Blockscout offers rich functionality: contract verification, token viewing (ERC-20, ERC-721, ERC-1155), NFT, DeFi metrics, REST API, and GraphQL. However, its stack (Elixir + PostgreSQL + Redis + node) is heavy: production requires at least 32 GB RAM, and initial setup is non-trivial.
Otterscan: Lightweight and Minimal
A lightweight explorer on React that works directly with an Erigon node via the extended ots_ namespace API. It does not need a separate database — all history is stored in the node itself. Pros: minimal footprint, no separate indexing, starts in minutes. Cons: requires exactly Erigon (not geth, not Nethermind), no contract verification, basic functionality.
The Graph: When You Need Custom Data
The Graph is not a full explorer, but if you need to display specific protocol data (e.g., liquidity volumes by pool or staking history), a subgraph + custom frontend will be faster and cheaper than a full explorer. It's not a replacement but a complement.
Platform Comparison
| Platform | Functionality | Infrastructure | Deployment Time | Contract Verification |
|---|---|---|---|---|
| Blockscout | Full: tokens, NFT, API, DeFi | PostgreSQL + Redis + node, ≥32 GB RAM | 2–4 weeks indexing | Yes, via Sourcify or API |
| Otterscan | Basic: transactions, blocks | Only Erigon node | Minutes | No |
| The Graph | Custom data via subscription | Subgraph + frontend | Hours–days | Only via subgraph |
Node Requirements for Different Platforms
| Platform | Node Type | Additional Methods | Disk Space (Ethereum mainnet) |
|---|---|---|---|
| Blockscout | Archive | debug_traceTransaction, trace_block | ~17 TB |
| Otterscan | Erigon (archive) | ots_* methods | ~17 TB (Erigon) |
| The Graph | Full or archive | Standard RPC | ~12 TB (full) |
How to Set Up an Explorer in 5 Steps
- Choose a platform — decide if you need full functionality (Blockscout), minimalism (Otterscan), or only custom metrics (The Graph).
- Prepare a node — Blockscout requires an archive node with debug/trace methods enabled. Otterscan requires Erigon. Ensure disk space can hold the full history.
- Deploy infrastructure — use Docker Compose for Blockscout or just run Erigon for Otterscan.
- Configure indexing — optimize batch size and parallel threads to speed up history loading.
- Verify and launch — connect Sourcify or manually verify contracts via API. Start the UI and configure SSL.
What Is Needed for Blockscout Deployment?
Infrastructure
We use Docker Compose for quick deployment. Below is a simplified config that we adapt to your tasks:
version: '3.8' services: db: image: postgres:15 environment: POSTGRES_DB: blockscout POSTGRES_USER: blockscout POSTGRES_PASSWORD: ${DB_PASSWORD} volumes: - postgres_data:/var/lib/postgresql/data shm_size: '512mb' redis: image: redis:7-alpine command: redis-server --maxmemory 4gb --maxmemory-policy allkeys-lru backend: image: blockscout/blockscout:latest depends_on: [db, redis] environment: DATABASE_URL: postgresql://blockscout:${DB_PASSWORD}@db:5432/blockscout ETHEREUM_JSONRPC_VARIANT: geth ETHEREUM_JSONRPC_HTTP_URL: http://node:8545 ETHEREUM_JSONRPC_WS_URL: ws://node:8546 ETHEREUM_JSONRPC_TRACE_URL: http://node:8545 SECRET_KEY_BASE: ${SECRET_KEY_BASE} CHAIN_ID: "1" COIN: ETH NETWORK: Mainnet SUBNETWORK: Ethereum Mainnet POOL_SIZE: 80 ECTO_USE_SSL: 'false' SOURCIFY_INTEGRATION_ENABLED: 'true' SOURCIFY_SERVER_URL: https://sourcify.dev/server ports: - "4000:4000" frontend: image: ghcr.io/blockscout/frontend:latest environment: NEXT_PUBLIC_API_HOST: http://backend:4000 NEXT_PUBLIC_NETWORK_NAME: My Network NEXT_PUBLIC_NETWORK_SHORT_NAME: MyNet NEXT_PUBLIC_NETWORK_ID: "1" ports: - "3000:3000" Node Requirements
Blockscout uses non-standard RPC methods: debug_traceTransaction for internal transactions, trace_block and trace_transaction for Parity-compatible traces, and eth_getBalance in archive mode. A regular full node is not enough — you need an archive node with debug/trace methods enabled. For Ethereum mainnet, the archive node size is about 17 TB. This is the main infrastructure cost. Example Geth launch:
geth --mainnet \ --syncmode full \ --gcmode archive \ --http \ --http.api eth,net,web3,debug,txpool \ --ws \ --ws.api eth,net,web3,debug \ --cache 32768 More about node requirements
For Blockscout to work correctly, the node must support:
-
debug_traceTransaction— for internal transactions -
trace_block,trace_transaction— for traces - Archive mode — otherwise balance data for old addresses will be unavailable.
Also ensure HTTP and WebSocket APIs are open, and the gas limit is at least 10 million.
How to Speed Up Indexing?
On first launch, Blockscout indexes history from the latest block backward. For mainnet, this can take 2–4 weeks. Optimize via variables:
BLOCK_TRANSFORMER: base INDEXER_BLOCK_REWARD_BATCH_SIZE: 10 INDEXER_COIN_BALANCES_BATCH_SIZE: 500 INDEXER_RECEIPTS_BATCH_SIZE: 250 INDEXER_INTERNAL_TRANSACTIONS_BATCH_SIZE: 20 For private networks with small history, full indexing takes hours. In one project, we deployed a Blockscout explorer for a private Ethereum network with 500k blocks. By tuning the indexer batch sizes and using a dedicated archive node with NVMe storage, we reduced initial indexing time from a projected 3 weeks to 10 days.
How to Verify Smart Contracts?
Verification through Sourcify — a decentralized repository of verified contracts. If a contract already exists in Sourcify, Blockscout pulls data automatically. Direct verification via REST API is also available by sending source code and compiler parameters:
curl -X POST http://localhost:4000/api \ -H "Content-Type: application/json" \ -d '{ "module": "contract", "action": "verifysourcecode", "contractaddress": "0x...", "sourceCode": "pragma solidity...", "codeformat": "solidity-single-file", "contractname": "MyContract", "compilerversion": "v0.8.20+commit.a1b79de6", "optimizationUsed": 1, "runs": 200 }' Custom Metrics and Branded UI
If you need a corporate style and non-standard pages, Blockscout allows setting custom tokens and native coin via env variables, forking the frontend (Next.js) and customizing the design, as well as adding extra pages like protocol metrics as separate React components.
What Is Included in the Work
We set up explorers for 15+ projects, including private networks and public L2s. Our turnkey process includes:
- Analysis: platform selection according to your requirements (network, metrics, budget).
- Design: infrastructure preparation, resource calculation for the archive node.
- Deployment: Docker Compose or Kubernetes, node and explorer configuration.
- Indexing: parallelism optimization, lag monitoring.
- Verification: Sourcify integration, API setup.
- Launch: Nginx reverse proxy with SSL, domain, alerts.
Timelines: from 2 to 3 weeks depending on network complexity and required customizations.
Get a consultation on setting up an explorer for your network. We guarantee stable indexer operation and prompt support. Contact us to discuss details and an individual deployment plan.