How to Retrieve All Ethereum Addresses and Their Balances Using Web3.js

The Ethereum blockchain is a vast, public ledger containing countless transactions and addresses. For developers, analysts, or enthusiasts, programmatically accessing this data can unlock powerful insights. Using the popular web3.js library, you can interact directly with the Ethereum network to retrieve information such as addresses and their corresponding balances. This guide will walk you through the process step by step.

Prerequisites and Setup

Before diving into the code, ensure you have Node.js and npm (Node Package Manager) installed on your system. These tools are essential for managing JavaScript packages and running your scripts.

To integrate the web3.js library into your project, you need to install it. If your network connection is slow, consider using a mirror like cnpm from Alibaba Cloud for faster downloads in certain regions. Install web3.js using the following commands in your terminal:

npm install -g cnpm --registry=https://registry.npm.taobao.org
cnpm install web3

This installs the necessary library to create a connection between your application and the Ethereum blockchain.

Core Concepts and Approach

The overall strategy for retrieving all addresses and their balances involves systematically traversing the blockchain's blocks and extracting transaction details. Here's the high-level logic:

1. Fetch the current block height to know how many blocks exist on the chain.
2. Iterate through all blocks, starting from the genesis block (block 0).
3. For each block, retrieve all transaction hashes contained within it.
4. For each transaction, get its detailed information, including the from (sender) and to (receiver) addresses.
5. Determine if an address is a smart contract or a standard user account.
6. Fetch the current balance for each unique address discovered.

This method ensures you process every transaction that has ever occurred on the network, capturing the involved addresses.

Step-by-Step Code Implementation

The following JavaScript code implements the logic described above. Create a new file, for example, ethAddress.js, and paste the code below.

var Web3 = require('web3');
console.log(Web3.version);

// Initialize a Web3 instance
// For testing, you might use a testnet RPC endpoint like Rinkeby:
// var web3 = new Web3('https://rinkeby.infura.io/');
var web3 = new Web3('https://mainnet.infura.io/'); // Mainnet Ethereum node

let addressList = []; // Array to store unique addresses

// Function to get the latest block number
function getBlockNumber() {
  web3.eth.getBlockNumber().then(function(result) {
    console.log("Latest Block Number: " + result);
    throughBlock(result);
  });
}

// Function to iterate from block 0 to the latest block
function throughBlock(blockNumber) {
  if (!blockNumber) {
    console.log('Block number is 0');
    return false;
  }
  for (var i = 0; i <= blockNumber; i++) {
    getBlock(i);
  }
}

// Function to get a specific block's details
function getBlock(blockNumber) {
  web3.eth.getBlock(blockNumber).then(function(result) {
    let transactions = result.transactions;
    for (var i = 0; i < transactions.length; i++) {
      getTransactions(transactions[i]);
    }
  });
}

// Function to get details of a specific transaction
function getTransactions(txHash) {
  web3.eth.getTransaction(txHash).then(function(result) {
    let fromAddress = result.from;
    let toAddress = result.to;
    getCode(fromAddress);
    getCode(toAddress);
  });
}

// Function to check if an address is a contract
function getCode(address) {
  if (!address) return false;
  web3.eth.getCode(address).then(function(result) {
    // If the code at the address is '0x', it is an Externally Owned Account (EOA)
    if (result === '0x') {
      getBalance(address);
    }
  });
}

// Function to get the balance of an address
function getBalance(address) {
  web3.eth.getBalance(address).then(function(result) {
    // Check if the address is new to our list to avoid duplicates
    if (!addressList.includes(address)) {
      addressList.push(address);
      console.log(address + "\t" + result); // Logs: Address [TAB] Balance
    }
  });
}

// Start the process
getBlockNumber();

Running the Script and Expected Output

To execute the script, open your terminal, navigate to the directory containing your ethAddress.js file, and run the command:

node ethAddress.js

The script will begin its execution. It will output the latest block number and then start logging unique Ethereum addresses along with their balances in Wei (the smallest denomination of ETH). Be patient; scanning the entire blockchain is a time-consuming process that requires making a vast number of API calls to your node provider.

Important Considerations and Limitations

While the provided code is a foundational example, it's crucial to understand its limitations for real-world use:

• Performance: Scanning the entire Ethereum mainnet, which has millions of blocks, will take an extremely long time and will make an enormous number of RPC calls.
• Rate Limiting: Most node providers (like Infura) have strict rate limits on their public endpoints. This script will likely hit those limits quickly without a paid plan or a dedicated node.
• Data Storage: The script simply logs data to the console. For a practical application, you would need to store the addresses and balances in a database or file.
• Balance Accuracy: The balance fetched is the current balance at the time of the query, not the historical balance at the time of the transaction the address was found in.

This code is best used as a learning tool to understand how to interact with the Ethereum blockchain using web3.js rather than as a production-ready solution.

Expanding on This Foundation

The principles demonstrated here form the basis for many blockchain analytics tools and explorers. With web3.js, you can build applications that:

• Track all transactions for a specific address.
• Monitor the real-time flow of ETH and tokens between addresses.
• Analyze historical trends and network activity.

👉 Explore advanced blockchain querying techniques

Platforms like Etherscan are built using similar underlying technology, querying blockchain data and presenting it in a user-friendly interface.

Frequently Asked Questions

What is Web3.js?
Web3.js is a collection of libraries that allow you to interact with a local or remote Ethereum node using HTTP, IPC, or WebSocket. It provides APIs to communicate with the Ethereum blockchain, enabling functionalities like sending transactions, reading blockchain data, and interacting with smart contracts.

What is the difference between a contract address and an externally owned account (EOA) address?
An Externally Owned Account (EOA) is controlled by a private key and has no associated code. A contract address is the address where a smart contract is deployed on the blockchain, and it has code associated with it. The getCode function in the script checks for this to differentiate between them.

Why does the script check if an address is a contract before getting its balance?
This step is included for demonstration and specificity. In practice, you can get the balance of any address, whether it's a contract or an EOA. The balance represents the amount of native ETH held by that address.

Can I use this to get the balance of ERC-20 tokens?
No, this script only retrieves balances of the native Ethereum cryptocurrency (ETH). ERC-20 tokens are managed by smart contracts. To get token balances, you need to interact with the specific token's contract using its ABI and methods like balanceOf(address).

What is Infura and why is it used in the code?
Infura provides reliable and scalable API access to the Ethereum network. It saves developers from having to run and maintain their own full Ethereum nodes. The code uses an Infura endpoint to connect to the Ethereum mainnet.

Is it possible to get the historical balance of an address using this method?
No, the getBalance function returns the current balance only. Calculating a historical balance requires replaying all transactions to and from that address up to a specific block number, which is a more complex operation.