An ERC-20 token creator turns a form into a deployed smart contract. You pick the name, ticker, decimals and supply, switch on the behaviour you want, and the contract lands on Ethereum mainnet signed by your own wallet.
Deployed from your wallet, never from ours. The owner key never leaves it.
Supply, mint, burn, limits, tax, permit and votes in one form. No Solidity.
One fee per deployment, whatever you switch on. No cut of your supply.
Network figures read from a public Ethereum node. Deployment cost is an estimate at the gas price shown. Fee and gas are separate: the fee reaches Northgate Protocol Labs, gas reaches the network.
ERC-20 is the interface described in EIP-20. A contract is an ERC-20 token when it implements six functions and emits two events. Every wallet, exchange listing and router on Ethereum reads exactly this surface, which is why a token that follows it works everywhere on day one.
| Member | Kind | What it does |
|---|---|---|
| totalSupply() | function | Reports how many units exist right now |
| balanceOf(address) | function | Reports the balance held by one address |
| transfer(address,uint256) | function | Moves units from the caller to another address |
| approve(address,uint256) | function | Lets a spender move units on the caller's behalf |
| allowance(address,address) | function | Reports how much a spender may still move |
| transferFrom(address,address,uint256) | function | Moves 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 |
These three are optional in EIP-20 but every wallet expects them. Decimals is the only one that cannot change later, because balances are stored as whole units and the decimal point is only a display rule. Eighteen is the Ethereum convention and matches ETH itself.
There is no protocol level supply. A token has one billion units because the constructor minted one billion units to an address. A cap, a mint function or a burn function are ordinary code that you either include or leave out.
Pausing, taxes, blocklists, permit signatures and voting power are not part of EIP-20. They are extra code layered on top of the same eight members, which is why a token with tax still shows up correctly in a wallet.
The builder groups the contract into six panels. Nothing is hidden behind a higher tier: the flat fee covers the whole list, and the summary panel keeps a running estimate of what your configuration costs to deploy.
How many units exist and whether that number can move.
Who is allowed to change anything after deployment.
Limits that apply once a pair exists.
A cut taken on buys, sells and plain transfers.
Standard interfaces beyond EIP-20.
What happens in the minutes after deployment.
Five steps, and the only irreversible one is the last.
Connect MetaMask, Rabby, Coinbase Wallet, Trust or any WalletConnect wallet, and switch it to Ethereum mainnet. The builder reads your address only to fill the owner and recipient fields.
Name, ticker, decimals and initial supply. Decimals is the one value that cannot be changed after deployment, so it is worth pausing on.
Walk the supply, access, trading, tax, extension and launch panels. The summary keeps a live count of what is on and what gas it adds.
The review panel lists every setting in plain words, flags combinations that fight each other, and shows the deployment cost at the current gas price.
One transaction pays the flat builder fee. The deployment follows and the contract address is yours from the moment it confirms.
One flat fee of 0.015 ETH for a deployment, whatever you switch on. There is no percentage of supply, no share of taxes, and no subscription.
A plain fixed-supply token costs roughly 900,000 gas to deploy. A token with tax, limits, permit and voting can reach about 2,400,000 gas. At 10 gwei that is the difference between roughly 0.009 ETH and 0.024 ETH in gas, which is why the builder shows the live figure before you sign.
There are three normal ways to get an ERC-20 contract on chain. Each one is right in different circumstances, and it is worth being direct about that.
| Route | What you need | Typical cost | Where it hurts |
|---|---|---|---|
| This builder | A wallet and a few minutes | 0.015 ETH plus gas | You accept a template rather than bespoke logic |
| OpenZeppelin Wizard plus Remix | Comfort with Solidity and compiler settings | Gas only | No tax, limits or launch tooling, and you carry every compiler and constructor mistake |
| Hiring a Solidity developer | A brief, a budget and review time | Usually four figures upward | Slow for a launch, and you still need an audit to make it worth the price |
| Forking a contract you found | A block explorer and optimism | Gas only | You inherit whatever backdoor the original author left in it |
If your token needs logic that is genuinely unusual, a developer and an audit are the honest answer. This builder is for the very common case: a standard token with well understood switches.
Short, direct answers to the things that decide whether a launch goes well.
Connect a wallet to Ethereum mainnet, fill in name, ticker, decimals and supply, switch on the behaviour you want, then sign the deployment. The contract address exists as soon as the transaction confirms, usually within a block or two. The only prerequisite is ETH in the wallet for the fee and for gas.
Two separate numbers. The builder fee here is a flat 0.015 ETH. Ethereum gas is paid to the network and depends entirely on the gas price at that moment and on how much code your contract contains, which is why the summary shows a live estimate rather than a fixed figure.
No. The contract is assembled from the options you pick and deployed from your wallet. Reading Solidity is still useful afterwards, because verified source on Etherscan is what lets buyers check that the token behaves as advertised.
Decimals only tells wallets where to put the decimal point. Balances are stored as whole units, so a supply of one million with 18 decimals is stored as one million followed by eighteen zeros. Eighteen matches ETH and every major token, and it is the safe default. Six is common for stablecoins. Zero makes a token indivisible, which is rarely what people want and cannot be undone.
Only if you switched on mintable, and only up to the cap if you set one. If mintable is off, total supply can go down through burns and can never go up. This is the single most read line in any token contract, so decide it deliberately.
It sets the owner to the zero address, so every owner-only function reverts forever. That removes the rug risk buyers worry about, and it also removes your ability to unpause, mint, adjust tax or fix a mistake. Renounce after the launch settles, not reflexively at deployment.
It still implements EIP-20, so wallets show it correctly. It is not fee-on-transfer safe for every integrator: a router that expects the exact amount it sent to arrive will revert unless it is told to support tax. That is why Uniswap has a separate supporting-fee-on-transfer path. Keep the rate modest and exclude the router and pair.
Permit lets a holder approve a spender with a signature instead of a transaction. The user signs off chain for free and the spender submits it, so a swap becomes one transaction instead of approve plus swap. It costs extra gas at deployment and saves your holders gas on every approval afterwards.
Verification publishes the exact source and compiler settings that produced the deployed bytecode. Etherscan then shows a Read and Write tab instead of raw hex. It is switched on by default here because an unverified contract is treated as a warning sign by most buyers and by every serious aggregator.
Create a pair on Uniswap with your token and ETH, deposit both sides, and you receive LP tokens that represent your share. The ratio you deposit sets the opening price. If you plan to lock the LP, do it immediately and publish the lock, because the gap between adding and locking is exactly when buyers are most exposed.
Yes, and you should. Sepolia behaves like mainnet for everything except real value, so a rehearsal there catches a wrong decimals value or a tax split that does not total 100 before it costs anything. Switch your wallet network and run the same form.
An unverified contract, a mint function with no cap, a pause switch held by a fresh wallet, a tax that the owner can raise without limit, a blocklist, and an upgradeable proxy. None of them are automatically malicious and every one of them is a lever the owner holds. If you switch them on, expect to explain why.
No. The deployment is signed by your wallet, the supply is minted to the address you choose, and the owner key is yours. The only thing that reaches us is the flat fee transaction.
MetaMask, Rabby, Coinbase Wallet, Trust, Rainbow, Brave Wallet and any other wallet that speaks WalletConnect. On a phone, open the site inside your wallet browser or connect through the WalletConnect sheet.
Yes, per deployment, regardless of which options you switch on. Gas is the variable part and it is paid to the network, not to us.
A failed transaction still burns the gas it consumed, because validators did the work. No fee is captured if the fee transaction itself reverts. If the fee confirmed and the deployment did not, contact support with the transaction hash.
Only through the controls you switched on. Name, ticker and decimals are fixed at deployment. Supply moves only if mintable or burnable are on. Tax and limits move only if you kept ownership.
No. The template follows well established patterns and is verified on Etherscan so anyone can read it, but that is not the same as an audit. If your token will hold significant value, commission one.
This builder targets Ethereum mainnet. The same contract shape works on any EVM chain, so tell us which one you need and we will say whether it is supported.
Yes, by email at build@erc20tokencreator.net and on Telegram. We can walk through verification, liquidity and the owner functions, but we cannot sign anything on your behalf.
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.