ERC-20 vs ERC-721 vs ERC-1155: When to Use Each Token Standard

Most projects pick a standard and never think about it again. That's how you end up with an NFT collection that costs $200 per mint because you chose ERC-721 instead of ERC-1155.

The Part Nobody Tells You

Standards exist because Ethereum devs got tired of auditing custom token implementations with zero safety checks. ERC-20 is fungible—every token is identical. ERC-721 is non-fungible—every token is unique. ERC-1155 is semi-fungible—you can have both in one contract.

The real decision tree isn't "what am I making?" It's "what are my users going to call, how often, and what will it cost?" Gas matters. Liquidity matters. Cross-protocol compatibility matters.

ERC-20: The Standard You Actually Understand

Fungible tokens. USDC, DAI, your shitcoin launch. Every token is worth the same. Supply is the only thing that changes.

Here's a minimal interface nobody should implement from scratch:

pragma solidity ^0.8.0;

interface IERC20 {
    function transfer(address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
}

Use this for liquidity pools, staking contracts, governance tokens, yield farming. Uniswap wouldn't exist without standardized ERC-20s.

Every transfer is a separate transaction. Want to send someone 100 tokens? One call. Send them 100 different tokens? 100 calls. Ronin lost $625M partly because bridges are complex and token handling is brittle. Not directly ERC-20's fault, but it's why you should use battle-tested contracts instead of rolling your own.

The Part Where You Realize ERC-721 Is Slow

Non-fungible. One token per ID. Could be an NFT, could be a deed, could be someone's identity credential.

pragma solidity ^0.8.0;

interface IERC721 {
    function transferFrom(address from, address to, uint256 tokenId) external;
    function mint(address to, uint256 tokenId) external;
    function ownerOf(uint256 tokenId) external view returns (address);
}

This is what OpenSea uses. This is what Azuki uses. This is what breaks when you try to send 50 NFTs at once. Don't mint 50 at a time without batching—I've seen this kill mainnet transactions.

Each token gets its own storage slot for metadata. You want to mint 10,000 NFTs? That's 10,000 individual state changes. Gas explodes. Projects learned this the hard way during 2022 mints when a single transaction cost more than some people's rent.

Use ERC-721 when each token is genuinely unique—art, collectibles, game assets that matter. Use it when you need OpenSea/Rarible/Blur integration immediately, or when you're launching an existing brand that demands "real NFT" status. Use it when you don't mind spending $5-15 per mint in gas fees.

Don't use it for anything you'd normally batch-transfer, game items like weapons or armor or consumables, loyalty programs with thousands of users, or anything requiring mechanical efficiency. Gas costs will destroy your product adoption.

Here's Where It Gets Weird: ERC-1155

Batch transfers. Both fungible and non-fungible tokens in one contract. Gamers and serious game developers use it. Everyone else ignores it.

pragma solidity ^0.8.0;

interface IERC1155 {
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
    function safeBatchTransferFrom(
        address from, 
        address to, 
        uint256[] calldata ids, 
        uint256[] calldata amounts, 
        bytes calldata data
    ) external;
    function balanceOf(address account, uint256 id) external view returns (uint256);
}

One call transfers 100 different items. That's gas efficient and why Enjin built their entire platform on it. The downside? Marketplace support sucks. OpenSea added ERC-1155 in 2021 and still treats it like a second-class citizen. Liquidity is fragmented. Most DEXs don't list ERC-1155 tokens.

Pick ERC-1155 when you're building a game or metaverse like Decentraland or The Sandbox, when you have both unique and fungible assets, when you want to send someone "50 gold tokens + 1 legendary sword" in one transaction, and when you understand the marketplace tradeoff. You're betting on in-game utility over open market liquidity.

The Real-World Hell: Protocol Interoperability

Euler Finance lost $197M partly because of smart contract bugs, but also because composability assumes token standards work everywhere. Your token doesn't follow ERC-20 perfectly? Flash loan contracts break. Your NFT doesn't emit proper Transfer events? Indexers miss it.

Here's what actually matters: always inherit from OpenZeppelin. Their implementations are audited. Never write custom token logic. Test against actual integrations—Uniswap, Aave, whatever your users touch.

// Right way
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor() ERC20("My Token", "MTK") {
        _mint(msg.sender, 1000 * 10 ** 18);
    }
}

// Wrong way (don't do this)
contract CustomToken {
    mapping(address => uint256) balances;

    function transfer(address to, uint256 amount) external {
        balances[msg.sender] -= amount;
        balances[to] += amount;
        // Forgot to emit Transfer? Goodbye indexing.
    }
}

The Decision Framework

Pick ERC-20 when you want fungibility, liquidity, and boring DeFi mechanics. Pick ERC-721 when you want marketplace integration, brand prestige, and don't mind gas. Pick ERC-1155 when you're building games or need batch efficiency and understand the marketplace tradeoff.

Don't overthink it. Standards exist because innovation without them is a security nightmare. Use what Vitalik's team blessed. Move fast.