How to Monitor Any Digital Asset Wallet Balance Using Python

·

Introduction

Managing digital assets effectively requires real-time monitoring of wallet balances. While exchange-based assets can be tracked via APIs, monitoring wallet-held assets requires a different approach. This guide explores how to use Python to query blockchain explorers for wallet balances across various cryptocurrencies.

Blockchain Explorers: The Gateway to Wallet Balances

Blockchain explorers serve as public ledgers for cryptocurrency transactions. They fall into two broad categories:

  1. Explorers with Public APIs (e.g., BTC.com, Etherscan)
  2. Explorers Without Public APIs (requiring web scraping techniques)

👉 Explore advanced blockchain analytics tools for comprehensive asset tracking.

Section 1: Explorers With Public APIs

1. Bitcoin Blockchain Explorer (BTC.com)

API Endpoint:
https://chain.api.btc.com/v3/address/<wallet_address>

Implementation:

import requests

def monitor_btc_balance(address, threshold=1):
    url = f'https://chain.api.btc.com/v3/address/{address}'
    while True:
        try:
            response = requests.get(url).json()
            balance = float(response['data']['balance']) / 10**8  # Convert satoshis to BTC
            if balance > threshold:
                alert_user(f"BTC balance reached: {balance}")
                break
            time.sleep(300)  # Check every 5 minutes
        except Exception as e:
            print(f"Error: {e}")
            time.sleep(60)

Key Considerations:

2. Ethereum Blockchain Explorer (Etherscan)

Requirements:

Implementation:

def get_eth_balance(address, api_key):
    base_url = "https://api.etherscan.io/api"
    params = {
        "module": "account",
        "action": "balance",
        "address": address,
        "tag": "latest",
        "apikey": api_key
    }
    response = requests.get(base_url, params=params).json()
    return float(response['result']) / 10**18  # Wei to ETH

For ERC-20 Tokens:

def get_token_balance(address, contract_address, api_key):
    params = {
        "module": "account",
        "action": "tokenbalance",
        "contractaddress": contract_address,
        "address": address,
        "tag": "latest",
        "apikey": api_key
    }
    # Similar request structure as above

Section 2: Explorers Without Public APIs

Case Study: ChainX (PCX Token)

Approach:

  1. Use browser developer tools (F12) to identify XHR requests
  2. Replicate headers and parameters in Python
  3. Parse JSON responses

Implementation:

def monitor_pcx_balance(address):
    url = f"https://api.chainx.org.cn/account/{address}/balance"
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
        "Accept": "application/json"
    }
    
    while True:
        try:
            response = requests.get(url, headers=headers).json()
            free_balance = response[1]['Free'] / 10**8  # Adjustment for decimals
            if free_balance > 30:
                send_alert(f"PCX purchased: {free_balance}")
                break
            time.sleep(180)
        except Exception as e:
            print(f"Monitoring error: {e}")
            time.sleep(60)

Best Practices for Wallet Monitoring

  1. Rate Limiting: Respect API rate limits (typically 5 requests/second)
  2. Error Handling: Implement robust try-catch blocks
  3. Data Validation: Verify API responses before processing
  4. Security: Never hardcode sensitive data (use environment variables)

👉 Discover secure wallet integration methods for enterprise solutions.

FAQ

Q1: How often should I check wallet balances?
A: For active trading, every 5 minutes. For long-term holdings, once daily is sufficient.

Q2: Can I monitor multiple wallets simultaneously?
A: Yes, using Python's threading or asynchronous programming.

Q3: How do I handle API key rotation?
A: Store keys in environment variables and implement a key rotation schedule.

Q4: What's the most common error in wallet monitoring?
A: Unit conversion errors (e.g., forgetting to convert wei/satoshis).

Q5: Can this technique work for private blockchains?
A: Only if they provide similar explorer functionality.

Conclusion

This comprehensive guide demonstrates how Python can interact with various blockchain explorers to monitor wallet balances. Whether using public APIs or web scraping techniques, developers can build robust monitoring solutions. Remember to:

For advanced implementations, consider adding: