How to Transfer ERC20 Tokens Using Web3.py in Ethereum

·

Transferring ERC20 tokens programmatically on the Ethereum blockchain has become a fundamental skill for blockchain developers, especially those working with decentralized applications (dApps), smart contracts, and automated transaction systems. One of the most powerful tools for achieving this is web3.py, a Python library that allows seamless interaction with Ethereum nodes.

In this comprehensive guide, we’ll walk through how to use web3.py to transfer ERC20 tokens—specifically focusing on sending tokens like USDT or custom tokens from one wallet to another. We'll explore code implementation, best practices, security considerations, and real-world applications.

Understanding the Basics: ERC20 and web3.py

Before diving into the code, it’s essential to understand two core concepts:

Together, they allow developers to build scripts that can check balances, send tokens, and even automate large-scale airdrops.

Setting Up Your Environment

To get started, ensure you have the following installed:

pip install web3 xlrd

You’ll also need:

🔐 Security Note: Never expose private keys in production code. Use environment variables or secure key management services.

Core Script Breakdown

Below is a refined version of the original script, optimized for clarity, structure, and functionality.

Step 1: Initialize Web3 Connection

from web3 import Web3
import json

# Connect to an Ethereum-compatible network (e.g., Hoo Smart Chain)
w3 = Web3(Web3.HTTPProvider('https://http-mainnet.hoosmartchain.com'))

if not w3.isConnected():
    raise Exception("Failed to connect to the blockchain node")

👉 Learn how to securely manage blockchain transactions using automated tools

Step 2: Load Token Contract ABI

The ABI defines how your script interacts with the smart contract. Here's a minimal ERC20 ABI:

abi = json.loads('''
[
    {"constant":true,"inputs":[{"name":"who","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},
    {"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}
]
''')

Step 3: Define Contracts and Checksum Addresses

Always use checksummed addresses to prevent errors:

iXT_ADDRESS = w3.toChecksumAddress('0x80c6A3A493aFd7C52f89E6504C90cE6A639783FC')
iUSDT_ADDRESS = w3.toChecksumAddress('0x09e6030537f0582d51C00bdC2d590031d9b1c86c')

iXT_CONTRACT = w3.eth.contract(address=iXT_ADDRESS, abi=abi)
iUSDT_CONTRACT = w3.eth.contract(address=iUSDT_ADDRESS, abi=abi)

Step 4: Read Wallet Data from Excel (Optional)

For batch operations, you might store addresses and private keys in a spreadsheet:

import xlrd
from collections import defaultdict

def load_wallet_data(file_name="wallets.xlsx"):
    data = defaultdict(str)
    workbook = xlrd.open_workbook(file_name)
    sheet = workbook.sheet_by_index(0)
    for i in range(sheet.nrows):
        address = sheet.cell_value(i, 0)
        private_key = sheet.cell_value(i, 1)
        data[address] = private_key
    return data
⚠️ Best Practice: Avoid storing private keys in plain files. This method is only for demonstration.

Step 5: Query Token Balance

Check the balance of a given address:

def get_token_balance(contract, address):
    checksum_address = w3.toChecksumAddress(address)
    raw_balance = contract.functions.balanceOf(checksum_address).call()
    return w3.fromWei(raw_balance, 'ether')

Step 6: Send ERC20 Tokens

Construct and sign the transaction:

def send_tokens(contract, from_address, private_key, to_address, amount):
    from_checksum = w3.toChecksumAddress(from_address)
    to_checksum = w3.toChecksumAddress(to_address)

    nonce = w3.eth.getTransactionCount(from_checksum)
    
    tx = contract.functions.transfer(
        to_checksum,
        w3.toWei(amount, 'ether')
    ).buildTransaction({
        'chainId': 70,  # Example chain ID; adjust based on network
        'gas': 241838,
        'gasPrice': w3.toWei('1', 'gwei'),
        'nonce': nonce,
    })

    signed_tx = w3.eth.account.signTransaction(tx, private_key)
    tx_hash = w3.eth.sendRawTransaction(signed_tx.rawTransaction)
    
    print(f"Transaction sent: {w3.toHex(tx_hash)}")
    return tx_hash

Frequently Asked Questions (FAQ)

Q1: Can I use this script on Ethereum mainnet?

Yes. Just replace the provider URL with an Ethereum mainnet RPC (e.g., from Infura or Alchemy) and ensure the chain ID matches (1 for Ethereum mainnet).

Q2: Why do I need the ABI?

The ABI tells web3.py how to encode function calls to interact with the smart contract. Without it, your script won’t know how to call transfer() or balanceOf().

Q3: Is it safe to automate token transfers?

Automation is safe if:

Avoid hardcoding credentials in source files.

Q4: What if the transaction fails?

Common causes include insufficient gas, incorrect chain ID, or zero balance. Always wrap transactions in try-except blocks and log errors.

Q5: Can I send native ETH instead of tokens?

Yes. Use w3.eth.send_transaction() instead of calling a token contract’s transfer() function.

Q6: How do I get the correct gas price?

Use dynamic gas pricing:

gas_price = w3.eth.gas_price

Or set it manually based on current network conditions.

Real-World Use Cases

This type of automation is ideal for:

👉 Discover how professional platforms streamline blockchain interactions at scale

Best Practices Summary

  1. Use environment variables for sensitive data.
  2. Test on testnets before deploying.
  3. Validate inputs (addresses, amounts).
  4. Handle exceptions gracefully.
  5. Monitor transaction status using w3.eth.wait_for_transaction_receipt().

Final Thoughts

Using web3.py to transfer ERC20 tokens gives developers full control over blockchain interactions. Whether you're managing a small wallet portfolio or building enterprise-grade blockchain solutions, mastering these fundamentals is crucial.

As blockchain adoption grows, so does the demand for reliable, secure automation tools. By combining Python’s simplicity with Ethereum’s robustness, you can build powerful applications that interact directly with decentralized networks.

Remember to always prioritize security and efficiency when handling real assets.

👉 Explore advanced blockchain development tools and resources