How to Create Wallet Addresses and Private Keys with Ethers.js

Ethers.js stands as one of the most widely adopted libraries for building blockchain applications. It empowers developers to seamlessly interact with Ethereum and Ethereum Virtual Machine (EVM) compatible chains, which include prominent networks like Polygon, Celo, and Base. This guide provides a foundational walkthrough for generating wallet addresses and private keys using this powerful library.

Understanding the Prerequisites

Before diving into the code, it's essential to grasp two core concepts: the library itself and the infrastructure that connects you to a blockchain.

Ethers.js is a compact, complete JavaScript library designed for Ethereum and EVM-based blockchain interactions. It offers a user-friendly experience for tasks ranging from querying data to sending transactions and managing wallets.

An RPC (Remote Procedure Call) endpoint is your direct gateway to a blockchain network. It allows your application to read on-chain data, broadcast transactions, and execute smart contracts. Think of it as the bridge between your code and the decentralized ledger.

For this tutorial, you will need a dedicated RPC endpoint. While several providers offer this service, we will use a generic approach. You can acquire a connection URL from any reputable Web3 infrastructure platform that supplies EVM chain endpoints.

Step-by-Step Implementation Guide

Step 1: Acquire an RPC Endpoint

Your first task is to obtain an RPC endpoint for your chosen EVM chain. This could be a mainnet or a testnet.

Navigate to a Web3 development platform's website.
Sign up for an account and navigate to your dashboard.
Create a new application or project, carefully selecting your desired chain and network (e.g., Ethereum Mainnet, Polygon Amoy Testnet).
From the project details, copy the HTTPS URL provided. This is your RPC endpoint.

Note: This demonstration uses the Polygon Amoy testnet, but the process is identical for any EVM-compatible chain. Always ensure you are using the correct endpoint for your target network.

Step 2: Set Up Your Development Environment

To use Ethers.js, you need a JavaScript runtime environment. Node.js is the standard choice for this.

Install Node.js: Ensure you have Node.js installed on your machine. Version 16 or later is recommended for optimal compatibility.
Initialize a New Project: Create a new directory for your project, open a terminal in that folder, and run npm init -y. This command generates a package.json file to manage your project's dependencies.
Install Ethers.js: In the same terminal, execute npm install ethers. This command downloads and installs the latest version of the Ethers.js library into your project's node_modules folder.
Create a Script File: Create a new file named index.js by running touch index.js in your terminal. This file will contain our wallet generation code.

Step 3: Write the Wallet Generation Script

Open the index.js file in your preferred code editor and input the following code:

const { ethers, Wallet } = require("ethers");

// Replace with your actual RPC endpoint URL
const rpcUrl = "YOUR_HTTPS_RPC_URL_HERE";

// Initialize a provider to connect to the blockchain
const provider = new ethers.JsonRpcProvider(rpcUrl);

// Generate a new random wallet
const wallet = Wallet.createRandom(provider);

// Extract the private key from the wallet object
const privateKey = wallet.privateKey;

// Log the complete wallet details and the private key to the console
console.log("Full Wallet Object:", wallet);
console.log("Private Key:", privateKey);

Step 4: Execute Your Code

Run your script by typing node index.js in your terminal. The script will connect to your specified blockchain network via the RPC provider, generate a new wallet, and print the results to your console.

The output will display an object containing the wallet's address, public key, and other metadata, followed by a long string of letters and numbers—the private key.

👉 Explore advanced wallet management techniques

Critical Security Considerations

Handling wallet information demands the highest level of security awareness. Your private key is the master key to your cryptocurrency holdings.

Never Share Your Private Key: Anyone with access to a wallet's private key has absolute control over all assets within it. Treat it with the same sensitivity as your online banking credentials.
Secure Storage: Never hardcode private keys into your application's source code, especially if it's publicly accessible. Use environment variables or secure secret management services.
Use Testnets for Development: Always practice and test on testnets like Sepolia or Amoy. Testnet assets have no real-world value, providing a safe sandbox for development.
Consider Hardware Wallets: For storing significant amounts of cryptocurrency, consider using a hardware wallet for cold storage, which keeps private keys entirely offline.

Frequently Asked Questions

What is an EVM-compatible chain?
EVM stands for Ethereum Virtual Machine. An EVM-compatible chain is any blockchain that can execute smart contracts using the same virtual machine as Ethereum. This allows developers to port applications from Ethereum to other chains like Polygon, Avalanche, and BNB Smart Chain with minimal changes.

Can I use this method to create a wallet for a specific chain?
Yes, absolutely. The chain specificity is determined by the RPC endpoint you provide. By using an RPC URL for Polygon, Avalanche, or any other EVM chain, the wallet you generate will be native to that network and its address will be valid on it.

Is it safe to generate wallets programmatically like this?
The cryptographic generation of keys using a well-audited library like Ethers.js is secure. The critical safety factor is how you handle the generated private key afterward. Ensure your application environment is secure and the private key is never exposed or stored in an insecure manner.

What is the difference between a private key and a seed phrase?
A private key grants access to a single cryptocurrency wallet. A seed phrase (or recovery phrase) is a human-readable list of words that can generate multiple private keys for a hierarchy of wallets. The Wallet.createRandom() method can also provide a mnemonic seed phrase.

Why does my wallet need to be connected to a provider?
Connecting the wallet object to a provider enables it to interact with the blockchain. This allows the wallet to check its balance, sign transactions, and estimate gas fees. The act of generating the key pair itself does not require a provider, but for it to be useful, the connection is essential.

Can I use this to import an existing wallet instead of creating a new one?
Yes, Ethers.js allows you to create a wallet instance from an existing private key or mnemonic. You would use new ethers.Wallet(privateKey, provider) to achieve this, giving you control over an existing account within your application.

👉 Get started with secure Web3 development

Conclusion

Generating wallet addresses and private keys with Ethers.js is a straightforward process that forms the bedrock of many Web3 applications. By following the steps outlined above—securing an RPC endpoint, setting up your environment, and writing a simple script—you can create wallets for any EVM-compatible blockchain. Remember that with great power comes great responsibility; always prioritize security when managing cryptographic keys. This foundational knowledge opens the door to more advanced blockchain development tasks, from building decentralized exchanges to crafting complex smart contract interactions.