eth_getBalance - zkSync RPC Method

Returns the balance of a given address on zkSync Era.

Why zkSync? Build on Matter Labs' flagship zkEVM powering the Elastic Network of interoperable hyperchains with ZK Stack modular framework, hyperchain interoperability, native account abstraction, and $1.9B in tokenized real-world assets.

When to Use This Method

eth_getBalance is fundamental for ZK developers, RWA tokenization teams, and builders launching custom L2/L3 chains:

• Wallet applications: Display user balances and enable balance-dependent operations on zkSync
• Transaction validation: Verify accounts have sufficient funds before submitting transactions to zkSync Era
• DeFi monitoring: Track collateral positions, liquidity pools, and TVL across RWA tokenization ($1.9B, 25% market share), hyperchain deployment via ZK Stack, and cross-chain DeFi
• Accounting and reconciliation: Cross-reference on-chain balances against off-chain ledger entries for financial reporting

Common Use Cases

1. Display Formatted Wallet Balance with Ether Conversion

Retrieve and display a human-readable balance for any address on zkSync Era. Convert the wei result to ether client-side using your web3 library.

import { JsonRpcProvider, formatEther } from 'ethers';

const provider = new JsonRpcProvider('https://api-zksync-era-mainnet-full.n.dwellir.com/YOUR_API_KEY');

async function displayBalance(address) {
  const balanceWei = await provider.getBalance(address);
  const balance = formatEther(balanceWei);
  console.log(`Balance: ${balance} zkSync`);
  return balance;
}

displayBalance('0x5AEa5775959fBC2557Cc8789bC1bf90A239D9a91');

2. Monitor Whale Wallet Activity with Polling and Threshold Alerts

Poll a high-value wallet on zkSync at regular intervals. Trigger an alert when the balance crosses a defined threshold, useful for tracking DeFi movements or exchange hot wallet activity.

from web3 import Web3
import time

w3 = Web3(Web3.HTTPProvider('https://api-zksync-era-mainnet-full.n.dwellir.com/YOUR_API_KEY'))
address = '0x5AEa5775959fBC2557Cc8789bC1bf90A239D9a91'
threshold_wei = w3.to_wei(100, 'ether')

def monitor_balance():
    previous_balance = w3.eth.get_balance(address)
    while True:
        time.sleep(15)
        current_balance = w3.eth.get_balance(address)
        if abs(current_balance - previous_balance) > threshold_wei:
            print(f'Balance changed by more than 100 zkSync')
        if current_balance > w3.to_wei(1000, 'ether'):
            print(f'Whale alert: wallet exceeds 1000 zkSync')
        previous_balance = current_balance

monitor_balance()

3. Historical Balance Tracking Using Block Tags

Query an account's balance at a specific block height to build a historical balance timeline. This is essential for audit trails, tax reporting, and analyzing wallet behavior over time on zkSync Era.

package main

import (
    "context"
    "fmt"
    "log"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, _ := ethclient.Dial("https://api-zksync-era-mainnet-full.n.dwellir.com/YOUR_API_KEY")

    address := common.HexToAddress("0x5AEa5775959fBC2557Cc8789bC1bf90A239D9a91")

    // Query balance at a specific block number
    blockNumber := big.NewInt(1000000)
    historicalBalance, _ := client.BalanceAt(context.Background(), address, blockNumber)
    fmt.Printf("Historical balance at block 1,000,000: %s wei\n", historicalBalance.String())

    // Query latest balance for comparison
    currentBalance, _ := client.BalanceAt(context.Background(), address, nil)
    change := new(big.Int).Sub(currentBalance, historicalBalance)
    fmt.Printf("Balance change: %s wei\n", change.String())
}

Best Practices

• Cache balances with short TTL: Set a 2-5 second cache duration for balance queries to reduce RPC calls while keeping data fresh enough for most UI use cases
• Convert wei to ether client-side: Use formatEther (ethers.js) or fromWei (web3.py) rather than relying on node-side conversion, which the JSON-RPC does not provide
• Use pending tag cautiously: Balances returned with the pending block tag may reflect unconfirmed state changes and differ from finalized on-chain values
• For batch balance queries, use eth_call with multicall: When querying balances for many addresses, bundle them through a multicall contract to reduce individual RPC round-trips

Code Examples

Error Handling

Related Methods

• eth_getCode - Get contract bytecode
• eth_getTransactionCount - Get account nonce