How to Send ERC-20 Tokens Using Web3.py and Python

Sending ERC-20 tokens is a foundational skill for any developer working in the Ethereum ecosystem. These fungible tokens power everything from decentralized finance (DeFi) platforms to NFT marketplaces and Web3 gaming. With Python’s powerful Web3.py library, you can programmatically interact with Ethereum smart contracts to transfer tokens and manage approvals with ease.

In this comprehensive guide, you’ll learn how to send ERC-20 tokens using Web3.py, set up your development environment, and securely approve smart contracts to spend your tokens on your behalf—all while following best practices for blockchain interaction.

Whether you're building dApps, automating token transfers, or exploring blockchain development, mastering these skills will significantly enhance your Web3 capabilities.

Understanding ERC-20 Tokens and Approvals

ERC-20 is the most widely adopted token standard on Ethereum. It defines a set of rules that all compliant tokens must follow, including functions like transfer(), balanceOf(), and approve().

The approve() function allows users to grant permission to a smart contract (or another address) to spend a specified amount of their tokens. This is essential for interacting with DeFi protocols such as Uniswap or Aave, where you must first approve token usage before depositing or trading.

This guide focuses on practical implementation using Web3.py, a Python library that enables seamless interaction with Ethereum nodes via JSON-RPC.

👉 Discover how easy it is to integrate blockchain functionality into your apps.

Setting Up Your Development Environment

Before writing any code, ensure your environment is properly configured.

Prerequisites

• Basic understanding of Ethereum and smart contracts
• Familiarity with Python programming
• A text editor or IDE (e.g., VS Code)
• Access to an Ethereum node (via services like QuickNode)
• An EVM-compatible wallet (e.g., MetaMask)

Required Dependencies

Install Web3.py using pip:

pip install web3

Ensure your Python environment is clean and dependencies are up to date to avoid common installation issues.

Step 1: Create a Web3 Connection Endpoint

To interact with the Ethereum blockchain, you need access to a node. While public nodes exist, they often suffer from latency and rate limits. For faster and more reliable performance, consider using a dedicated node provider.

You can deploy an endpoint on Ethereum Sepolia (or other EVM chains like Polygon or Arbitrum) through services that offer high-performance RPC access. Once created, you'll receive an HTTPS URL to connect your application.

Keep this RPC URL handy—you’ll use it in your Python script to initialize the Web3 instance.

Note: Although we use Sepolia for testing, the same process applies to mainnet and other EVM-compatible blockchains.

Step 2: Fund Your Test Wallet

To perform transactions, your wallet needs ETH to cover gas fees—even on testnets.

Use a multi-chain faucet to obtain test ETH for Sepolia. Simply connect your wallet or paste your address to receive funds. Some faucets may require a small mainnet balance (e.g., 0.001 ETH) for anti-abuse measures.

Once funded, you're ready to begin coding.

Step 3: Send ERC-20 Tokens Using Web3.py

Now, let’s write the code to transfer tokens.

Create the Main Script

Create a file named main.py and add the following:

from web3 import Web3
from web3.middleware import geth_poa_middleware
import json

# Configuration
RPC_URL = 'YOUR_QUICKNODE_ENDPOINT'
CONTRACT_ADDRESS = Web3.to_checksum_address('ERC20_CONTRACT_ADDRESS')
TO_ADDRESS = Web3.to_checksum_address('RECIPIENT_ADDRESS')
private_key = 'YOUR_PRIVATE_KEY'

if not private_key:
    raise ValueError("Private key not provided.")

# Initialize Web3
w3 = Web3(Web3.HTTPProvider(RPC_URL))
w3.middleware_onion.inject(geth_poa_middleware, layer=0)

if not w3.is_connected():
    raise ConnectionError("Failed to connect to Ethereum node")

# Load ABI from file
with open('abi.json') as f:
    contract_abi = json.load(f)

# Set up contract
contract = w3.eth.contract(address=CONTRACT_ADDRESS, abi=contract_abi)

# Define transfer amount (in smallest unit)
token_amount = w3.to_wei(1, 'ether')  # Adjust as needed

# Get account and nonce
account = w3.eth.account.from_key(private_key)
nonce = w3.eth.get_transaction_count(account.address)

# Build transaction
transaction = contract.functions.transfer(TO_ADDRESS, token_amount).build_transaction({
    'chainId': w3.eth.chain_id,
    'gas': 200000,
    'gasPrice': w3.eth.gas_price,
    'nonce': nonce,
})

# Sign and send
signed_txn = w3.eth.account.sign_transaction(transaction, private_key)
try:
    tx_hash = w3.eth.send_raw_transaction(signed_txn.rawTransaction)
    print(f"Transaction sent! Hash: {tx_hash.hex()}")
except Exception as e:
    print(f"Error: {e}")

Prepare the ABI File

Create an abi.json file in the same directory containing the token contract’s ABI. You can retrieve this from block explorers like Etherscan if the contract is verified.

Step 4: Approve Smart Contracts to Spend Tokens

Sometimes, you need to allow a smart contract to use your tokens—such as when providing liquidity or staking.

Use the approve() function instead of transfer():

spender_address = Web3.to_checksum_address('CONTRACT_TO_APPROVE')
transaction = contract.functions.approve(spender_address, token_amount).build_transaction({
    'chainId': w3.eth.chain_id,
    'gas': 200000,
    'nonce': nonce,
})

After approval, the contract can call transferFrom() to move tokens from your wallet up to the approved limit.

👉 Learn how to automate smart contract interactions securely.

Frequently Asked Questions

What is an ERC-20 token?

ERC-20 is a technical standard for fungible tokens on Ethereum. It defines methods for transferring tokens, checking balances, and approving spending allowances.

Do I need ETH to send ERC-20 tokens?

Yes. All Ethereum transactions require gas paid in ETH, even when sending non-native tokens like USDT or DAI.

Where do I get a contract’s ABI?

You can find verified contract ABIs on block explorers like Etherscan under the "Contract" tab. Copy the JSON interface and save it locally.

Can I use this method on other blockchains?

Yes! This approach works on any EVM-compatible chain—just update the RPC URL and chain ID accordingly.

Is it safe to use my private key in code?

For production applications, never hardcode private keys. Use environment variables or secure key management tools like hardware wallets or vaults.

What happens if I lose my private key?

Losing your private key means losing access to your wallet and all its assets. Always store keys securely offline or use mnemonic phrases with proper backup.

👉 Secure your crypto workflow with advanced tools and insights.

Final Thoughts

You now have the knowledge and tools to send ERC-20 tokens and manage approvals using Python and Web3.py. These skills are essential for building robust decentralized applications, automating financial operations, or integrating blockchain into backend systems.

As blockchain technology evolves, developers who understand low-level interactions will be at the forefront of innovation in DeFi, tokenization, and Web3 infrastructure.

Explore further by experimenting with different token standards (like ERC-721 for NFTs), integrating event listeners, or building full-stack dApps. The possibilities are vast—and just beginning.

Core Keywords: ERC-20 tokens, Web3.py, Python blockchain development, Ethereum transactions, smart contract interaction, token transfer, approve function, EVM-compatible chains