What is a dev buy? It is the creator of a coin buying some of their own token inside the same transaction that launches it, before anybody else can trade. If you have ever opened a brand-new coin and seen the dev already holding 5% of the supply one second after launch, you were looking at a dev buy.
If you searched this and landed on Trust Wallet's glossary, that page is useful, but it answers a neighbouring question. Its entry on "buying the devs" describes traders "buying a newly launched token very early, based on the activity or involvement of its developers or developer-linked wallets." That is a strategy for watching devs. This post is about the dev's own purchase.
We run Runitup, a launchpad live on five chains, and our launch form has a dev buy field. So everything below is checked against the live form, the contract code and the 529 coins launched on our site so far. Where a number comes from Runitup, we say so.
What is a dev buy, exactly?
"Dev" is community shorthand for whoever launched the coin. Platforms tend to say "creator". Same person.
A dev buy is an ordinary purchase from the coin's pool, with one difference: it is bolted onto the launch itself. On Runitup the field is labelled "Dev buy (optional)", and the hint under it says exactly what it does: "Buys your own token inside the launch transaction, so nothing can trade ahead of it."
A few things are always true on Runitup:
- It is paid for. The creator's ETH goes into the pool and tokens come out, at the pool's price. Nothing is minted for free.
- It lands in the creator's wallet. The tokens are sent to the launching wallet, where anyone can see them.
- It is optional. More than half of the coins on our site launched without one.
- It is entered in dollars by default. A small toggle switches the field to ETH, and the form converts between the two.
That second point matters more than it looks. On Runitup the pool opens holding 100% of the supply, so there is no team allocation and no presale. If a dev holds tokens at launch, they bought them, and they paid the pool for every one.
Why the dev buy happens inside the launch transaction
A blockchain transaction runs as one indivisible unit. Either every step in it happens, in order, or none of it does. Nobody can squeeze a trade into the middle.
Runitup's TokenFactory contract does the launch in this order, all in one transaction:
- Creates the token with its fixed supply.
- Opens the pool with the whole supply in it and no ETH, at the starting price.
- Sends the liquidity position straight to the locker.
- Runs the dev buy, swapping the creator's ETH for tokens.
- Announces the launch on chain.
Only after that transaction is mined can anyone else see the coin and send a trade. By then the creator's purchase has already happened, at the opening price.
Without one, the creator would launch, then buy in a second transaction like everyone else. Automated sniper bots watch for new pools and can easily get there first. Buying inside the launch removes that race for the creator. It does nothing to stop bots buying right after, and Runitup's stealth option does not either: the form says plainly that hiding a launch from the site's listings "stops people browsing the site, not snipers."
Does a dev buy pay the trading fee?
It depends on how the coin was launched, and the form tells you which.
On a Quick launch with the v1 pool fee, the creator's buy pays the pool's 1% like any other trade. The form's own words: "Your dev buy pays the 1%." Since the creator receives 75% of that fee, most of it comes back to them later.
On a v2 hook-fee launch, or an Advanced (taxed) launch, the creator's buy runs before the hook is switched on, and the pool has no fee of its own, so it pays nothing. Runitup's docs say the token page then shows buyers that the creator bought this way, and how much.
How a dev buy is priced: a worked example
This is the part most explanations skip. Here is the actual arithmetic, using the live numbers.
The inputs, from Runitup's live config on 27 October 2026:
- A coin paired with ETH opens at a starting market cap of 1.5 ETH. With ETH at about $2,339, the form shows that as $3.51K.
- The default supply is 1,000,000,000 tokens.
Step 1: the opening price. Starting market cap divided by supply:
1.5 ETH ÷ 1,000,000,000 = 0.0000000015 ETH per token (about $0.0000035).
Step 2: the naive answer. If price did not move, 0.1 ETH would get:
0.1 ÷ 0.0000000015 = 66.7 million tokens, or 6.67% of supply.
That is wrong, for two reasons. The fee comes off first, and every token you buy makes the next one slightly more expensive.
Step 3: take off the fee. On a v1 pool, 1% of 0.1 ETH is 0.001 ETH, so 0.099 ETH actually buys tokens.
Step 4: apply the pool's math. For a pool like this, the share of supply you get is:
share = buy ÷ (starting market cap + buy) = 0.099 ÷ (1.5 + 0.099) = 0.099 ÷ 1.599 = 6.19%
That is about 61.9 million tokens.
Step 5: the market cap afterwards. The price rises with the square of how much ETH went in:
new market cap = (1.5 + 0.099)² ÷ 1.5 = 2.557 ÷ 1.5 = 1.7045 ETH, about $3,990.
So the dev paid an average of 0.1 ÷ 61.9 million = 0.0000000016 ETH per token, about 8% above the opening price. The next buyer starts about 13.6% above it.
The live form agrees. Type 0.1 ETH into the field and it shows "≈ $233.95 · 6.2% of supply", and the starting market cap row changes to "$3.51K → $3.99K". That is the screenshot near the top of this post.
Why the number is only approximate
The form calls its percentage an estimate, and it means it. The real figure depends on the price at the moment your transaction lands, and the dollar value moves with ETH. Our figures above are rounded, and the 6.2% assumes a v1 pool. On a hook-fee launch with no fee on the dev buy, the same 0.1 ETH gets 0.1 ÷ 1.6 = 6.25%.
Supply does not change the answer
Notice that supply never appears in the share formula. Spending 0.1 ETH gets about 6.2% of the coin whether the supply is a billion or a million. A bigger supply just makes each token cheaper by the same proportion. Runitup's docs on the starting market cap make the same point: "Choosing a larger supply does not make your launch bigger."
What different sizes get you
Same assumptions, other amounts:
| Dev buy | In dollars | Share of supply | Market cap after |
|---|---|---|---|
| 0.01 ETH | $23 | 0.66% | 1.52 ETH ($3,556) |
| 0.05 ETH | $117 | 3.2% | 1.60 ETH ($3,744) |
| 0.1 ETH | $234 | 6.2% | 1.70 ETH ($3,988) |
| 0.25 ETH | $585 | 14.2% | 2.04 ETH ($4,763) |
| 0.5 ETH | $1,170 | 24.8% | 2.65 ETH ($6,207) |
| 1 ETH | $2,339 | 39.8% | 4.13 ETH ($9,670) |
The curve flattens fast. Doubling the spend never doubles the share. To own half the supply at launch you would need about 1.5 ETH after the fee, and the market cap would quadruple on your own buy.
Other chains use their own opening figure but the same formula. On BNB Chain the pool opens at about 5.04 BNB, and on Arc it opens at 2,700 USDC. Swap that number in for 1.5 and the arithmetic works the same way.
The reason the formula looks like this is the single-sided pool: the launch behaves like a pool holding 1.5 ETH of liquidity that nobody actually deposited. Our post on meme coin liquidity walks through that in detail.
How big is a normal dev buy?
There is no official rule, so here is what real creators actually do. We read the launch-transaction purchase of every live coin on Runitup through the site's public token API on 27 October 2026.
- 529 live coins across five chains.
- 281 (53%) launched without one.
- 248 (47%) made one.
- Among those, the median dev buy was 4.6% of supply, and the middle half sat between 1.3% and 5.2%.
- 94 were between 5% and 10%. Only two were 10% or more, and one of those took about three quarters of its own supply.
- On the ETH chains, the median one cost about 0.077 ETH, roughly $180 today.
So on our site, "normal" is either nothing or a small buy, a few percent of supply. A bag in double digits is rare enough that buyers notice it.
Our own rough reading, which is an opinion and not a rule:
- Under 5%: ordinary. The dev has some skin in the game.
- 5% to 10%: visible. Worth a look at what the dev does next.
- Over 10%: buyers will ask why, and they are right to.
- Over 25%: the dev can move the chart on their own. Treat it that way.
How buyers read a dev's bag
A dev buy is a snapshot of the first second. What careful buyers want to know is what the dev holds now.
That is why Runitup's token page has a Creator holds figure in its Top holders tab, showing what the launching wallet holds right now. The docs put it plainly: it is "the figure to look at rather than a launch-day dev-buy number, because it is current."
Our data shows why. Of the 242 launches with a creator buy where the site shows a Creator holds figure, 205 now show the launching wallet holding about zero. We checked three of those wallets directly on chain, and each held a balance of exactly 0. Selling is not the only explanation, since a dev can also move tokens to another wallet, but either way the launch snapshot no longer describes the bag.
Here is what to check, in order:
- Creator holds, today. A high number means the dev can still sell. Zero means they already have, or moved the tokens.
- Top 10 hold. If ten wallets own most of the supply, the coin moves on their decisions.
- Fresh wallets in the first block. If several new wallets bought right after launch, they may belong to the dev. You cannot prove it, and Trust Wallet's glossary is honest about that: "Wallet ownership can also be difficult to attribute with certainty."
- Transfers out of the dev wallet. Open the creator's address on the chain's explorer, such as Robinhood Chain's Etherscan, and look at token transfers. Splitting a bag across wallets is a pattern worth noticing.
- How the dev gets paid. On Runitup a creator earns 0.75% of every trade's value on a Quick launch, paid automatically. A dev with an income from volume has less reason to sell the bag, though nothing stops them.
When a dev buy is a red flag
Most dev buys are fine. These patterns are the ones to slow down for.
The bag is large. Look at the table again: on our ETH chains, 0.5 ETH buys about a quarter of the supply. A dev holding that much can drop the price hard with a single sell, whatever their intentions.
The dev buy is small, but the first block is crowded. A tiny labelled buy next to a cluster of new wallets buying in the opening seconds can be one person spread across many wallets. The labelled part is the honest part of that picture.
The bag disappears fast. A launch buy followed minutes later by Creator holds dropping to zero means the dev took the first bounce. That is a trade, not a commitment.
A fee-free dev buy on a coin with a sniper window. On hook-fee and taxed launches the creator's buy runs before the sniper window opens and pays no fee, while early buyers pay up to 80%. That is by design and disclosed on the token page, but a big dev buy under those conditions deserves a second look.
What is not a red flag: no buy at all, which is what most coins on our site do, or a few percent that the dev still holds.
Should you make a dev buy?
If you are the one launching, here is the trade-off.
For it: you are first in line, at the opening price, with no bot ahead of you. Buyers can see you have a stake. A few percent is the norm among the coins on our site that bought.
Against it: it is real money leaving your wallet. On a v1 pool it pays the 1% fee. And your bag becomes a number every buyer watches. If you sell later, you sell into your own chart, publicly.
How to size it: decide the share first, then let the form do the conversion. At today's opening valuation on ETH chains, roughly:
| Share you want | Dev buy needed (v1) | In dollars |
|---|---|---|
| 1% | 0.015 ETH | $36 |
| 5% | 0.080 ETH | $187 |
| 10% | 0.168 ETH | $394 |
| 20% | 0.379 ETH | $886 |
These use the same formula in reverse: buy = share × 1.5 ÷ (1 − share), plus the 1% fee.
Two practical notes. If you pair your coin with something other than ETH, such as USDG or a tokenized stock, the dev buy is paid in that asset and the form asks you to approve the spend first. And our field-by-field guide to the launch settings covers the dev buy alongside every other choice on the form.
Dev buy questions people ask
Can anyone trade before my dev buy?
No. It runs inside the launch transaction, after the pool opens and before the transaction finishes. Nobody else can see the coin until that transaction is mined.
Is a dev buy the same as a team allocation?
No. A team allocation is tokens handed to the team for free. This is bought from the pool at the market price. On Runitup the whole supply goes into the pool at launch, so buying is the only way a creator holds tokens on day one.
Can I sell my dev buy later?
Yes, whenever you like. The tokens are in your wallet like anyone else's. Everyone will see it on the token page, because Creator holds updates live.
Does a dev buy add liquidity?
Yes, in a sense. The ETH you spend stays in the pool, so after a 0.1 ETH purchase on a v1 pool, about 0.099 ETH sits there for later sellers to sell into. Our post on meme coin liquidity, linked above, explains why the pool starts with none.
Why did my dev buy get slightly less than the form said?
The form shows an estimate based on the price before your transaction. Rounding, the fee and the live ETH price all nudge the final number a little.
Do I need a dev buy for my coin to work?
No. More than half the coins on Runitup launched without one, and they trade the same way from the first block.
A dev buy is one of the few honest signals in a new coin: it is on chain, it is labelled, and it was paid for. Read it alongside Creator holds, not instead of it. If you are launching, keep it modest, and when you are ready, the launch page shows you the exact share before you sign anything.
