How to Create and Deploy an ERC20 Token

Creating and deploying your own ERC20 token on the Ethereum blockchain may sound like a complex task reserved for elite developers—but in reality, it’s more accessible than ever. Whether you're building a community token, launching a decentralized project, or just exploring Web3 development, this guide walks you through how to create an ERC20 token step by step. You'll learn both the quick way—using pre-built libraries—and the manual method, writing every line of code yourself.

By the end, you’ll understand the essential functions every ERC20 token must include, how to deploy your token to a live testnet (like Sepolia), and how to add it to MetaMask for easy viewing.

Why Build an ERC20 Token?

ERC20 is the most widely adopted standard for fungible tokens on Ethereum. It defines a set of rules that ensure compatibility across wallets, exchanges, and decentralized applications (dApps). From stablecoins like USDT to governance tokens like UNI, most digital assets you interact with are built using this standard.

Understanding how to create an ERC20 token gives you foundational knowledge in smart contract development and opens doors to participating in DeFi, NFT ecosystems, and DAOs.

👉 Discover how easy blockchain development can be with the right tools

Method 1: Create an ERC20 Token in 6 Lines of Code

Thanks to powerful open-source libraries like OpenZeppelin, creating a fully compliant ERC20 token can be done in just a few lines. Here's how:

1. Set up your development environment using Hardhat or Foundry.

2. Install OpenZeppelin:

   npm install @openzeppelin/contracts

3. Create a new Solidity file (MyToken.sol) and write:

pragma solidity ^0.8.0;

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

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

That’s it—just six meaningful lines! This contract:

• Inherits from OpenZeppelin’s ERC20 base contract
• Sets the name (MyToken) and symbol (MTK)
• Mints 1,000 tokens to the deployer’s address

This approach is fast, secure, and follows best practices. But if you want deeper understanding, let’s look at building one from scratch.

Method 2: Build an ERC20 Token Manually (No Libraries)

Building without OpenZeppelin helps you grasp what happens under the hood. Below is a minimal yet compliant ERC20 implementation:

pragma solidity ^0.8.0;

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

contract MyManualToken is IERC20 {
    string public name = "ManualToken";
    string public symbol = "MNT";
    uint8 public decimals = 18;
    uint256 public override totalSupply;

    mapping(address => uint256) public override balanceOf;
    mapping(address => mapping(address => uint256)) public override allowance;

    constructor() {
        totalSupply = 1000 * 10 ** decimals;
        balanceOf[msg.sender] = totalSupply;
    }

    function transfer(address recipient, uint256 amount) external override returns (bool) {
        require(balanceOf[msg.sender] >= amount, "Insufficient balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[recipient] += amount;
        emit Transfer(msg.sender, recipient, amount);
        return true;
    }

    function approve(address spender, uint256 amount) external override returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
        require(balanceOf[sender] >= amount, "Insufficient balance");
        require(allowance[sender][msg.sender] >= amount, "Not approved");
        balanceOf[sender] -= amount;
        balanceOf[recipient] += amount;
        allowance[sender][msg.sender] -= amount;
        emit Transfer(sender, recipient, amount);
        return true;
    }

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

Key Functions Explained

Even though this version takes more work, it gives you full control and deeper insight into Ethereum’s token mechanics.

👉 Start experimenting with smart contracts using trusted blockchain infrastructure

Deploying Your ERC20 Token to Sepolia Testnet

Once your contract is ready:

1. Compile the contract using Hardhat or Remix IDE.
2. Get testnet ETH from a faucet like Sepolia's official provider or a multi-chain faucet.
3. Connect your wallet (e.g., MetaMask) to the Sepolia network.
4. Deploy the contract via Hardhat script or Remix.

Example Hardhat deployment script (deploy.js):

async function main() {
  const MyToken = await ethers.getContractFactory("MyToken");
  const myToken = await MyToken.deploy();
  await myToken.deployed();
  console.log("Token deployed to:", myToken.address);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

After deployment, verify your contract on Etherscan for transparency and trust.

Add Your ERC20 Token to MetaMask

To view your token in MetaMask:

1. Open MetaMask and go to the “Assets” tab.
2. Click “Import Tokens.”
3. Paste your contract address.
4. The token symbol and decimals should auto-fill.
5. Confirm and add.

Your custom token will now appear in your wallet balance.

Frequently Asked Questions (FAQ)

Q: Do I need real ETH to deploy an ERC20 token?
A: No—you can use testnet ETH on networks like Sepolia or Goerli for development and testing purposes.

Q: Is creating an ERC20 token free?
A: While writing the code is free, deploying it to Ethereum requires gas fees. However, testnets allow you to deploy at no cost using test ETH.

Q: Can I change my token after deployment?
A: No—once deployed, smart contracts are immutable. Always test thoroughly before going live.

Q: What are common uses for custom ERC20 tokens?
A: They’re used for community rewards, loyalty programs, governance voting, fundraising (ICOs), and as utility tokens in dApps.

Q: How do I make my token deflationary or mintable?
A: Extend your contract with features like _burn() for deflation or add mint() functions (with access control) for future supply increases.

Q: Are all ERC20 tokens the same?
A: While they follow the same interface, behavior can differ based on added logic—such as pausing transfers or charging fees.

Final Thoughts

Learning how to create and deploy an ERC20 token is a valuable skill in today’s blockchain-driven world. Whether you choose the fast route with OpenZeppelin or build manually for educational purposes, each method strengthens your grasp of Web3 fundamentals.

With tools becoming increasingly user-friendly and networks like Sepolia offering free testing environments, there's never been a better time to start building.

👉 Jumpstart your Web3 journey with powerful tools and resources

Core Keywords:

• create ERC20 token
• deploy ERC20 token
• ERC20 token tutorial
• Ethereum smart contract
• build token on blockchain
• add token to MetaMask
• Web3 development
• Solidity programming