If you’ve used stablecoins, exchange tokens, or governance coins on Ethereum, you’ve already touched ERC-20—even if you didn’t know it. ERC-20 is the most widely used fungible token standard on Ethereum, defining the common rules wallets, exchanges, and apps expect. Thanks to that common language, your tokens “just work” across the ecosystem.
What “ERC-20” actually means
ERC-20 is a standard interface—a set of functions and events every compliant token contract must expose. The original spec (EIP-20) defines six required functions (totalSupply, balanceOf, transfer, transferFrom, approve, allowance) and two events (Transfer, Approval). Implementing these makes a token interoperable with wallets, DEXes, and other smart contracts.
Put simply: ERC-20 makes different tokens behave predictably. That predictability is why the standard became the default for fungible assets (stablecoins, points, utility tokens, etc.) on Ethereum and EVM networks.
How ERC-20 transfers and approvals work
There are two common ways tokens move:
- Direct transfer — you call transfer(recipient, amount). Your balance goes down, theirs goes up. This is the simplest path many wallets use.
- Approve + transferFrom — you first call approve(spender, amount) to grant an allowance. Later, the spender (a DEX, lending protocol, or another contract) pulls tokens with transferFrom(owner, spender, amount). This is what enables DeFi to move your tokens with your permission.
The “permit” shortcut (fewer clicks, no approval gas)
Approvals usually require an on-chain transaction (you pay gas). EIP-2612 (“permit”) lets you sign an off-chain message authorizing an allowance, which the app submits for you. Result: one fewer transaction and a smoother UX. Many modern ERC-20s implement permit in addition to the classic functions.
A word on allowance safety
The original spec flags a race-condition risk: if you change a non-zero allowance, a malicious spender might use the old allowance before your update lands. The conservative pattern is to set allowance to 0 first, then set the new value (or use permit, which many interfaces handle more safely). Always review spending approvals in your wallet and revoke unused ones.
ERC-20 vs. other token standards (ERC-721 & ERC-1155)
- ERC-20 = fungible tokens (each unit is identical). Think currencies, points, votes.
- ERC-721 = non-fungible tokens (unique items—NFTs).
- ERC-1155 = a multi-token standard that can handle both fungible and non-fungible types (and batch transfers) in a single contract—useful for games and complex inventories.
Knowing the difference helps when you’re picking wallets, bridges, or marketplaces that support the asset you hold.
Fees, networks, and addresses
ERC-20 tokens live on Ethereum (and EVM-compatible chains). Transfers cost gas paid in the network’s native coin (on Ethereum L1, that’s ETH). Wallets show the contract address for each token—verify this on a trusted explorer before interacting to avoid fakes. Ethereum’s developer docs keep an up-to-date overview of ERC-20 behavior and expectations that most apps follow.
How developers create ERC-20 tokens
You don’t have to reinvent the wheel. Well-audited libraries like OpenZeppelin Contracts provide standard ERC-20 implementations you can import, extend, and deploy—often with optional extras (burnable, pausable, permit). These templates encode best practices and are widely used in production.
At a high level, an ERC-20 token contract:
- Imports a base ERC-20 implementation
- Sets name, symbol, and decimals (metadata functions many UIs read)
- Mints an initial supply (or defines a mint function)
- Emits standard events on transfers/approvals
If you’re new, work through an official tutorial or a reputable walkthrough before pushing to mainnet. (Developer docs from Ethereum and major infra providers clearly outline the six mandatory functions and typical patterns.)
Common ERC-20 use cases
- Stablecoins (on-chain dollars) for payments and trading
- Governance tokens to vote in DAOs
- Utility & reward tokens for apps, games, and loyalty programs
- Liquid staking tokens representing staked assets
All of these rely on the same predictable interface that wallets and DEXes support out of the box—the core value of the ERC-20 standard.
Security checklist for everyday users
- Verify the token’s contract address before buying or swapping (look it up via a trusted link or explorer). ERC-20’s consistency helps UIs recognize legit tokens, but copycats exist.
- Limit approvals: give the smallest sensible allowance; revoke unused approvals regularly. The EIP-20 spec itself warns about allowance updates—use apps that support permit when available.
- Prefer reputable templates if you’re deploying a token (OpenZeppelin), and get audits for contract changes.
- Mind gas: on Ethereum L1, busy times raise fees; consider L2s or schedule transactions when network demand is lower. (Wallets and explorers show live fee estimates.)
Troubleshooting: why a transfer might fail
- Insufficient gas or funds (you need native ETH to pay fees).
- Allowance not set (apps need approve/permit before they can pull tokens).
- Wrong network or token (e.g., you’re on a testnet or looking at an impostor contract).
- Token with extra rules (some tokens add pauses, blacklists, or fees; check the docs).
If in doubt, start with a tiny test transfer and read the transaction error in your explorer.
Quick glossary
- ERC-20 token standard — the rulebook tokens follow to be compatible across Ethereum apps.
- Allowance — the max amount a spender (like a DEX) can take from your wallet via transferFrom.
- Permit (EIP-2612) — sign once off-chain to approve spending; the app submits it, saving you a transaction.
- Decimals — how many decimal places a token uses (UIs rely on this to display balances).
ERC-20 vs. real coins: why ETH looks different
ETH is Ethereum’s native coin (used for gas). ERC-20 tokens are smart contracts that track balances. That’s why ETH transfers use a different mechanism than token transfers, and why you sometimes need ETH to move an ERC-20 token. The developer docs highlight ERC-20 as a token standard living on top of Ethereum—not a replacement for ETH.