Quantum Chainquantumcha.in ↗
Indexed chain data

Read important blockchain data from the explorer.

The Quantum Mainnet explorer provides a public, Blockscout-compatible REST API. Use it to search indexed blocks, transactions, addresses, tokens, contracts, transfers, and logs without operating an indexer.

API location

Use REST v2 on Quantum Mainnet.

Explorerhttps://qntmscan.io
REST base URLhttps://qntmscan.io/api/v2
Interactive referencehttps://qntmscan.io/api-docs

Public read requests use HTTP GET and return JSON. The basic endpoints do not require an API key. Set a deadline, require a successful HTTP status, and parse the body as untrusted input.

Mainnet onlyThe REST examples on this page read Quantum Mainnet, chain ID 20803. The lightweight Sandbox explorer at explorer.sandbox.qustody.io does not currently expose Blockscout REST v2. Use the JSON-RPC reference for programmatic Sandbox data.
Read-only data sourceThe explorer API is for indexed reads. Do not send private keys, seeds, signatures awaiting attachment, or authenticated application secrets to it. Submit signed transactions through JSON-RPC, not the explorer API.
Copy and run

Get network, block, transaction, and address data.

These examples require curl and jq. They select current objects, so they remain copyable as the chain advances.

Network statistics

terminal
EXPLORER_API="https://qntmscan.io/api/v2"

curl --fail-with-body --max-time 20 "$EXPLORER_API/stats" | jq '{
  total_blocks,
  total_transactions,
  total_addresses,
  average_block_time,
  network_utilization_percentage,
  gas_prices
}'

Latest indexed block

terminal
EXPLORER_API="https://qntmscan.io/api/v2"
LATEST_BLOCK="$(curl --fail-with-body --max-time 20 "$EXPLORER_API/blocks" |
  jq -r '.items[0].height')"

curl --fail-with-body --max-time 20 \
  "$EXPLORER_API/blocks/$LATEST_BLOCK" | jq '{
    height, hash, timestamp, transactions_count,
    gas_used, gas_limit, miner: .miner.hash
  }'

Latest indexed transaction

terminal
EXPLORER_API="https://qntmscan.io/api/v2"
TX_HASH="$(curl --fail-with-body --max-time 20 "$EXPLORER_API/transactions" |
  jq -r '.items[0].hash')"

curl --fail-with-body --max-time 20 \
  "$EXPLORER_API/transactions/$TX_HASH" | jq '{
    hash,
    status,
    result,
    block_number,
    timestamp,
    from: .from.hash,
    to: (.to.hash // null),
    value,
    fee: .fee.value,
    gas_used,
    nonce,
    raw_input
  }'

status is normally ok or error for an indexed transaction. A null to can mean contract creation. Keep value, fees, gas values, and other large quantities as strings until converting them with an arbitrary-precision integer or decimal type.

Address balance and activity

terminal
EXPLORER_API="https://qntmscan.io/api/v2"
ADDRESS="$(curl --fail-with-body --max-time 20 "$EXPLORER_API/transactions" |
  jq -r '.items[0].from.hash')"

curl --fail-with-body --max-time 20 \
  "$EXPLORER_API/addresses/$ADDRESS" | jq '{
    hash,
    coin_balance,
    is_contract,
    is_verified,
    has_tokens,
    has_token_transfers
  }'

curl --fail-with-body --max-time 20 \
  "$EXPLORER_API/addresses/$ADDRESS/transactions" |
  jq '.items[] | {hash, status, block_number, timestamp, value}'
Endpoint map

Choose the resource you need.

RequestUse it for
GET /statsNetwork totals, block time, utilization, and gas-price estimates
GET /blocksPaginated recent blocks
GET /blocks/{height_or_hash}One block and its gas, miner, fee, size, and timestamp fields
GET /blocks/{height_or_hash}/transactionsTransactions included in one block
GET /transactionsPaginated recent transactions
GET /transactions/{hash}Status, block, participants, value, fees, gas, calldata, and decoded input
GET /transactions/{hash}/logsEvent logs emitted by one transaction
GET /transactions/{hash}/token-transfersToken movements produced by one transaction
GET /transactions/{hash}/internal-transactionsIndexed internal execution calls
GET /addresses/{address}Native balance and account or contract metadata
GET /addresses/{address}/transactionsTransactions involving one address
GET /addresses/{address}/token-transfersToken-transfer history for one address
GET /addresses/{address}/tokensIndexed token holdings for one address
GET /tokensPaginated token catalog
GET /tokens/{token_address}Token metadata, decimals, supply, and holder count
GET /tokens/{token_address}/holdersPaginated token holders
GET /tokens/{token_address}/transfersPaginated transfers for a token contract
GET /smart-contracts/{address}Contract bytecode and available verification metadata
GET /search?q={query}Search for an address, transaction, block, or token

Use the explorer's interactive API reference for optional filters and the complete live schema. The interface follows Blockscout REST API conventions, with Quantum-specific deployment behavior controlled by Quantum Chain.

Response interpretation

Read the fields without losing precision.

FieldMeaningHandling rule
timestampUTC time in ISO 8601 formatParse as timezone-aware UTC, not local time
value, coin_balanceNative value in the smallest 18-decimal unitKeep as a string or arbitrary-precision integer
fee.valueActual or maximum transaction fee in the smallest unitInspect fee.type before interpreting it
status, resultIndexed transaction execution outcomeRequire success for completed application operations
block_number, confirmationsInclusion height and current indexed depthDo not treat an explorer count as immutable finality
from.hash, to.hashSender and recipient addressesto may be null for contract creation
raw_inputTransaction calldataKeep as hexadecimal bytes; do not assume UTF-8 text
decoded_inputBest-effort ABI decodingMay be null when contract metadata is unavailable
itemsOne page of list resultsNever assume the first page is the complete history
next_page_paramsOpaque cursor fields for the next pageForward every returned field unchanged

Convert amounts and timestamps in Python

Python
from datetime import datetime
from decimal import Decimal


def atomic_to_quantum(value: str) -> Decimal:
    return Decimal(value) / Decimal(10**18)


def parse_explorer_time(value: str) -> datetime:
    return datetime.fromisoformat(value.replace("Z", "+00:00"))

A token can use a different decimal count. Read decimals from GET /tokens/{token_address} before formatting a token balance.

Pagination

Forward the cursor returned by the API.

List responses contain items and either an object or null in next_page_params. Cursor fields vary by endpoint. Do not invent page numbers and do not keep only one cursor field.

terminal
EXPLORER_API="https://qntmscan.io/api/v2"
FIRST_PAGE="$(curl --fail-with-body --max-time 20 "$EXPLORER_API/blocks")"

echo "$FIRST_PAGE" | jq '.items[] | {height, hash, timestamp}'

NEXT_QUERY="$(echo "$FIRST_PAGE" | jq -r '
  .next_page_params
  | to_entries
  | map("\(.key)=\(.value | tostring | @uri)")
  | join("&")
')"

if [ -n "$NEXT_QUERY" ]; then
  curl --fail-with-body --max-time 20 \
    "$EXPLORER_API/blocks?$NEXT_QUERY" |
    jq '.items[] | {height, hash, timestamp}'
fi

Stop when next_page_params is null. Bound the number of pages and records for interactive requests and background jobs.

Reusable caller

Read and paginate with the Python standard library.

explorer.py
import json
from urllib.parse import urlencode
from urllib.request import Request, urlopen

BASE_URL = "https://qntmscan.io/api/v2"


def get_json(path, params=None):
    query = urlencode(params or {})
    url = f"{BASE_URL}{path}" + (f"?{query}" if query else "")
    request = Request(url, headers={"accept": "application/json"})
    with urlopen(request, timeout=20) as response:
        if response.status != 200:
            raise RuntimeError(f"explorer returned HTTP {response.status}")
        return json.loads(response.read())


def iter_items(path, max_pages=10):
    cursor = None
    for _ in range(max_pages):
        page = get_json(path, cursor)
        yield from page["items"]
        cursor = page.get("next_page_params")
        if not cursor:
            return


stats = get_json("/stats")
print("indexed blocks", stats["total_blocks"])
print("indexed transactions", stats["total_transactions"])

for block in iter_items("/blocks", max_pages=2):
    print(block["height"], block["hash"], block["timestamp"])

For production, add bounded retries for safe GET requests, backoff with jitter, response-size limits, metrics, and schema validation. Never retry indefinitely.

Operational rules

Explorer data is indexed and eventually consistent.