How to Send Ethereum (ETH) Transactions Using Web3.js in Node.js

·

Sending Ethereum (ETH) transactions using Web3.js in a Node.js environment is a foundational skill for developers building decentralized applications (dApps). Whether you're creating smart contracts, DeFi platforms, or blockchain-based services, understanding how to programmatically transfer ETH is essential. This guide walks you through the complete process—from setup to execution—with clear, secure, and production-ready practices.

The core technologies involved—Node.js, Web3.js, and the Ethereum blockchain—form a powerful stack for interacting with the decentralized web. By the end of this article, you’ll be able to send ETH transactions securely, understand gas mechanics, and avoid common pitfalls.

Setting Up Your Development Environment

Before diving into code, ensure your development environment is ready.

First, install Node.js and npm (Node Package Manager) if they aren’t already installed on your machine. You can verify this by running:

node --version
npm --version

Once confirmed, initialize a new project and install the Web3.js library:

npm init -y
npm install web3

This installs the latest version of Web3.js, enabling you to interact with the Ethereum network via HTTP/RPC.

👉 Learn how to securely manage blockchain transactions with advanced tools

Connecting to an Ethereum Node

To interact with the Ethereum blockchain, your application must connect to a node. You can use:

Here’s how to connect using a local Ganache instance:

const Web3 = require('web3');

// Connect to local Ethereum node (e.g., Ganache)
const provider = new Web3.providers.HttpProvider('http://localhost:8545');
const web3 = new Web3(provider);

If you're using a remote provider like Infura, replace the URL with your project endpoint:

const provider = new Web3.providers.HttpProvider('https://sepolia.infura.io/v3/YOUR_PROJECT_ID');

Always keep sensitive credentials like API keys out of your source code—use environment variables instead.

Loading Accounts and Managing Keys Securely

To send ETH, you need a funded Ethereum account. For security reasons, never hardcode private keys in your source files.

Instead, load them from environment variables:

# .env file
PRIVATE_KEY=0xabc123...
INFURA_URL=https://sepolia.infura.io/v3/YOUR_ID

Then access them in Node.js:

require('dotenv').config();
const privateKey = process.env.PRIVATE_KEY;

Use Web3.js to create an account object from the private key:

const account = web3.eth.accounts.privateKeyToAccount(privateKey);
web3.eth.accounts.wallet.add(account);

Now you can reference account.address for transactions.

Checking Account Balance

Before sending ETH, check the sender's balance to avoid failed transactions due to insufficient funds.

async function checkBalance(address) {
  const balanceWei = await web3.eth.getBalance(address);
  const balanceEth = web3.utils.fromWei(balanceWei, 'ether');
  console.log(`Balance: ${balanceEth} ETH`);
}

checkBalance(account.address);

This uses web3.utils.fromWei() to convert the balance from wei (the smallest unit) to ether, making it human-readable.

Sending an ETH Transaction

Now comes the main action: sending ETH. Here’s a complete async function that sends 1 ETH:

async function sendEth(recipientAddress, amountInEth) {
  const amountInWei = web3.utils.toWei(amountInEth.toString(), 'ether');

  const tx = {
    from: account.address,
    to: recipientAddress,
    value: amountInWei,
    gas: 21000, // Standard gas limit for simple transfers
    gasPrice: await web3.eth.getGasPrice(), // Fetch current market rate
  };

  try {
    const receipt = await web3.eth.sendTransaction(tx);
    console.log('Transaction successful!');
    console.log('Hash:', receipt.transactionHash);
  } catch (error) {
    console.error('Transaction failed:', error.message);
  }
}

// Example usage
sendEth('0xRecipientAddressHere', 1);

Key Parameters Explained:

👉 Discover how real-time blockchain data improves transaction reliability

Understanding Gas Fees and Transaction Costs

Every Ethereum transaction requires gas, which compensates miners or validators. The total cost is:

Total Cost = Gas Used × Gas Price

While simple transfers use a fixed 21,000 gas, complex smart contract interactions may consume more. Always estimate gas when possible:

tx.gas = await web3.eth.estimateGas({ to: recipientAddress, value: amountInWei });

Monitoring network congestion helps avoid delays. Tools like Etherscan or OKX’s gas tracker provide insights into optimal timing.

Best Practices for Security and Reliability

  1. Never expose private keys in code or logs.
  2. Use .env files and .gitignore to protect secrets.
  3. Validate addresses using web3.utils.isAddress().
  4. Handle exceptions with try/catch.
  5. Test on testnets (e.g., Sepolia) before going live.
  6. Monitor transaction hashes on block explorers.

Frequently Asked Questions (FAQ)

How do I install Web3.js in a Node.js project?

Run npm install web3 after initializing your project with npm init. Ensure Node.js and npm are installed first.

Can I send ETH without paying gas fees?

No. All Ethereum transactions require gas fees paid in ETH. The sender must have enough ETH not only for the transfer amount but also for gas.

What is the difference between Wei and Ether?

Wei is the smallest denomination of ETH (1 ETH = 10¹⁸ Wei). Use web3.utils.toWei() and web3.utils.fromWei() to convert between them.

Why does my transaction keep failing?

Common causes include insufficient funds, incorrect nonce, low gas price, or network issues. Always check error messages and verify your node connection.

Is it safe to use private keys in backend code?

Only if they’re securely stored (e.g., environment variables, vaults). Avoid committing them to version control. Consider using wallet APIs or hardware wallets for better security.

Can I use Web3.js with other blockchains?

Yes! Web3.js works with any EVM-compatible chain like BSC, Polygon, or Arbitrum—just change the provider URL.

Final Thoughts

Using Web3.js in Node.js to send ETH transactions is straightforward once you understand the components: connecting to a node, managing accounts securely, estimating gas, and handling errors gracefully. With proper practices, you can build reliable blockchain integrations that scale.

As Ethereum continues evolving with upgrades like EIP-4844 and proto-danksharding, staying updated on gas efficiency and tooling improvements will give you a competitive edge.

👉 Stay ahead with up-to-date crypto development resources and tools

Whether you're building a wallet service, exchange integration, or DeFi protocol, mastering ETH transfers is your first step into the world of decentralized technology. Keep experimenting, test thoroughly, and always prioritize security.