What an ERC-20 token actually is
ERC-20 is not a product or a platform. It is an interface described in EIP-20: a list of functions and events that a contract has to implement before wallets, explorers and routers will treat it as a fungible token. If your contract implements them, every EVM tool understands it on day one with no integration work from anyone.
That surface is smaller than most people expect. Six functions, two events, and three optional metadata getters that every wallet nonetheless assumes are present.
| Member | Kind | What it does |
|---|---|---|
| totalSupply() | function | How many units exist right now |
| balanceOf(address) | function | The balance held by one address |
| transfer(address,uint256) | function | Move units from the caller to someone else |
| approve(address,uint256) | function | Let a spender move units on your behalf |
| allowance(address,address) | function | How much a spender may still move |
| transferFrom(...) | function | Move units using an existing allowance |
| Transfer(from,to,value) | event | Emitted on every movement, indexers read this |
| Approval(owner,spender,value) | event | Emitted when an allowance changes |
| name() symbol() decimals() | optional | Metadata every wallet expects anyway |
Everything else people talk about, taxes, blocklists, pausing, voting power, permit signatures, is extra code layered on top of those eleven members. That is why a token with a 4 percent sell tax still shows up correctly in MetaMask: the tax lives inside the transfer path, and the interface above it is unchanged.
It also explains the single most common misunderstanding: an ERC-20 contract does not store a logo. There is no image field in the standard. Your logo reaches wallets and charts through explorer and aggregator submissions after deployment, never through the contract itself.
What you need before you start
Four things, and none of them take long. Getting all four ready before you open the builder is the difference between a six minute deployment and an hour of switching tabs.
An EVM wallet
MetaMask, Rabby, Coinbase Wallet, Trust, Rainbow or anything that speaks WalletConnect. On a phone, open the site inside the wallet browser rather than a normal browser.
ETH on Ethereum mainnet
Enough for the builder fee of 0.015 ETH plus gas. Gas moves constantly, so keep a margin rather than the exact figure.
Name, ticker and supply decided
Check the ticker is not already carried by a well known token. Name and ticker are written into the constructor and cannot be edited later.
A destination for the supply
Your connected wallet by default. If a treasury or multisig should hold it from block one, have that address ready.
Optional but strongly recommended: rehearse the whole thing on Sepolia first. It behaves exactly like mainnet except the value is fake, and it catches a wrong decimals value before it costs anything.
How to create an ERC-20 token, step by step
Six steps. Only the last one is irreversible, and everything before it can be changed as many times as you like.
- 1
Open the builder and connect a wallet
Go to the builder and connect. Check the network reads Ethereum mainnet before anything else, because a wallet sitting on a testnet or on another chain is the most common reason a deployment goes to the wrong place.
- 2
Enter the name and ticker
The name is what wallets display, two to forty-two characters. The ticker is the short symbol, two to eleven letters or digits, upper case by convention. Neither can be changed after deployment.
- 3
Set decimals and initial supply
Decimals is a display rule only, and eighteen is the Ethereum convention. Initial supply is the number minted in the deployment transaction to you or to the address you name. Pause here: decimals is the one field with no second chance.
- 4
Switch on the behaviour you want
Work through supply, access, trading, extensions and launch. The next section covers what each one does and which are permanent. A plain fixed-supply token needs none of them.
- 5
Review the summary
The summary lists every setting in plain words, flags combinations that fight each other, and shows the deployment gas your specific configuration needs at the gas price the network is charging right now.
- 6
Pay 0.015 ETH and deploy
One transaction pays the flat fee, and the deployment follows. The contract address is yours from the moment it confirms, and the supply is in the wallet you named.
That is the whole flow
The builder keeps your draft in the browser, so you can walk the panels, close the tab and come back to the same configuration. Nothing is sent anywhere until you connect a wallet and sign.
Every setting, and which ones you can never change
This is the part worth reading twice. A setting is permanent when it changes the bytecode, and adjustable when it only changes a value the contract reads at runtime. Nobody can add a mint function to a deployed contract, but the owner can lower a tax rate any afternoon.
The table below is the honest version. "Permanent" means a new deployment is the only way to change it.
| Setting | After deployment | Why |
|---|---|---|
| Name and ticker | Permanent | Written into the constructor as stored strings |
| Decimals | Permanent | A compiled constant, balances are stored as whole units |
| Initial supply | Permanent | Minted once at deployment, moves only through mint or burn |
| Mintable | Permanent | The function is either in the bytecode or it is not |
| Hard cap | Permanent | An immutable constant that every mint call checks |
| Burnable | Permanent | Same, the burn function has to exist from the start |
| Burn on transfer | Rate adjustable | The mechanism is permanent, the percentage is a stored value |
| Owner address | Adjustable | transferOwnership, which is how you move to a multisig |
| Renounce ownership | One way | Once the owner is the zero address it can never be set again |
| Role based access | Permanent | AccessControl storage has to be compiled in |
| Pausable | State adjustable | The switch is permanent, pausing and unpausing is not |
| Blocklist and allowlist | Entries adjustable | The list mechanism is permanent, its contents are not |
| Trading switch | One way | The mechanism is permanent, and opening trading cannot be undone |
| Max transaction and max wallet | Values adjustable | Limits are stored percentages the owner can raise or lift |
| Transfer cooldown | Value adjustable | Seconds are a stored value |
| Buy, sell and transfer tax | Rates adjustable | The tax path is permanent, the rates are stored |
| Tax split and marketing wallet | Adjustable | Both are stored values |
| EIP-2612 permit | Permanent | The EIP-712 domain separator is fixed at deployment |
| ERC20Votes | Permanent | Checkpoint storage must exist from the first transfer |
| Snapshots | Permanent | Same, the snapshot machinery is compiled in |
| Flash mint and ERC-1363 | Permanent | Interfaces cannot be added to deployed bytecode |
| Upgradeable proxy | Logic adjustable | Whether the token is upgradeable at all is decided once |
| Etherscan verification | Any time | Verification is off chain, you can do it a year later |
Read the "Permanent" rows as your real decision list. Everything marked adjustable can wait until after the launch, and in most cases should, because a narrow limit you lift on a published schedule reads far better than a wide one you never touch.
One combination the builder blocks outright: a max transaction set above the max wallet. It compiles, it deploys, and then every buy above the wallet cap reverts. That is the kind of mistake that costs a launch window rather than a form error.
What it actually costs
Two numbers, and only one of them is ours.
The builder fee here is a flat 0.015 ETH per deployment, whatever you switch on. There is no percentage of supply, no cut of your taxes, no subscription, and no per-feature pricing. Turning on tax, permit, voting and a liquidity lock costs exactly the same as deploying a plain fixed-supply token.
Ethereum gas is the variable, and it is paid to validators rather than to us. Gas units depend on how much code your configuration contains; the gas price depends on network demand at the minute you sign. The builder multiplies the two and shows the result before you commit.
| Configuration | Approximate gas | At 10 gwei |
|---|---|---|
| Plain fixed supply, burnable | ~900,000 | ~0.009 ETH |
| Plus limits and a trading switch | ~1,050,000 | ~0.011 ETH |
| Plus buy and sell tax | ~1,270,000 | ~0.013 ETH |
| Plus EIP-2612 permit | ~1,440,000 | ~0.014 ETH |
| Everything, including votes and a proxy | ~2,400,000 | ~0.024 ETH |
Those gas figures are estimates for planning, not quotes. The exact number depends on the compiler version, the optimizer setting and the constructor arguments, which is why the builder recalculates for your specific configuration rather than quoting a fixed figure.
It is worth comparing this to the two common alternatives. A per-feature pricing model charges you again for every switch, so a token with tax, anti-bot limits and branding can end up several times the base price. Hiring a developer usually starts in the four figures and still needs an audit to be worth it. A flat fee is simply a different trade: you accept a well understood template instead of bespoke logic.
The first hour after you deploy
The contract existing is not the launch. This is the order that keeps the gap between "deployed" and "safe to buy" as short as possible.
- Minute 0
Verify the source on Etherscan
Verification publishes the exact source and compiler settings behind the deployed bytecode, turning a page of hex into a readable contract with Read and Write tabs. Until it is verified, nobody can confirm the token does what you say, and most aggregators will not index it.
- Minute 5
Open liquidity
Create the pair on Uniswap with your token and ETH. The ratio you deposit sets the opening price. Until a pool exists the token is transferable, which is enough for an airdrop, but nobody can buy it.
- Minute 6
Lock the LP and publish the lock
The window between adding liquidity and locking it is exactly when buyers are most exposed, and the first thing they check. Lock immediately and post the link rather than promising to do it later.
- Minute 10
Open trading, then watch the limits
If you used the trading switch, this is when you flip it. Keep max transaction and max wallet narrow for the first minutes, then lift them on a schedule you announced in advance.
- Hour 1
Branding and listings
Submit your logo and links to the explorer and to the chart aggregators. A pair with full branding reads as a real project; an unnamed contract with a grey placeholder reads as an exit.
Five mistakes that quietly ruin a launch
None of these are exotic. They are the ones that come up again and again in support messages, and every one of them is avoidable in the builder.
Renouncing ownership at deployment
It looks like the strongest possible trust signal, and it is, but it also permanently removes your ability to unpause, lift a limit, lower a tax or fix anything at all. Renounce after the launch settles. Moving ownership to a multisig and publishing the signer set gets you most of the trust at none of the cost.
Choosing decimals without thinking
Zero decimals makes the token indivisible forever. Six is right for a stablecoin and wrong for almost everything else. Eighteen is the convention for a reason. This is the only field with no recovery path other than deploying again.
A tax rate with no ceiling in code
If the owner can raise the tax to any number after launch, every scanner and every experienced buyer will flag it, and some aggregators will refuse to list. Set a rate you can defend, and keep the hard cap that limits how far it can ever go.
Max transaction above max wallet
The two limits look independent and are not. If a single transaction may exceed what a wallet is allowed to hold, every buy above the wallet cap reverts and your pair looks broken in the first minutes.
Leaving the contract unverified
It costs nothing and takes minutes, and skipping it is read as deliberate. An unverified contract with real liquidity behind it is the single fastest way to lose buyers who were otherwise ready.
Frequently asked questions
A flat 0.015 ETH builder fee here, whatever features you switch on, plus Ethereum gas paid to the network. Gas runs roughly 900,000 units for a plain token and up to about 2,400,000 for a fully loaded one, so at 10 gwei that is somewhere between 0.009 and 0.024 ETH.
No. You fill in the form, review the summary and sign two transactions. Reading Solidity is still useful afterwards, because verified source on Etherscan is what lets other people check the token behaves as advertised.
About six minutes of configuration and one or two blocks of confirmation. Opening liquidity and verifying the source afterwards takes another ten or fifteen minutes.
The wallet that signs the deployment. The supply is minted to the address you name and the owner key never leaves your wallet. We never ask for a seed phrase or a private key, and the only signatures the site requests are the fee transaction and the deployment.
You can add one in the builder for the preview, but no ERC-20 contract stores an image on chain, so the logo does not live in the token itself. After deployment you submit it to the explorer and to the chart aggregators, which is where wallets read it from.
The rate, yes, if you kept ownership and switched the tax mechanism on at deployment. The mechanism itself cannot be added later. If there is any chance you will want a fee, enable it at a low percentage rather than hoping to bolt it on.
Only once a pool exists. A freshly deployed token is transferable, which is enough to run an airdrop or fund a treasury, but nobody can buy it until you add liquidity.
Yes, and it is ten minutes well spent. Sepolia behaves like mainnet in every way that matters except the value, so a rehearsal catches a wrong decimals value or a tax split that does not total 100 before it costs anything real.
No. The template follows well established patterns and is verified on Etherscan so anyone can read it line by line, but that is not the same as an audit. If your token will hold significant value, commission one.
An unverified contract, a mint function with no cap, a pause switch held by a fresh wallet, a tax the owner can raise without limit, a blocklist, and an upgradeable proxy. None are automatically malicious, and every one is a lever the owner holds, so if you switch one on, expect to explain why.
In short
Creating an ERC-20 token on Ethereum is one form and two signatures. The work that matters happens before the second one: decimals, whether supply can grow, who holds the owner key, and which protections go into the bytecode, because those are the choices a new deployment is the only way to undo.
Start with the smallest contract that does what you need. Add a limit or a tax only when the launch actually calls for it, publish what you switched on, and lift the temporary controls on a schedule you said out loud.
Ready when you are
Flat 0.015 ETH per deployment on Ethereum mainnet, signed from your own wallet, every option included.