On this page
Start
Overview
level launches coins on the real pump.fun bonding curve: same curve, same graduation, same liquidity. What changes is around it: who deploys, what gets block 0, what's allowed to launch, and where the creator fee goes.
- You pay
- 0.035 SOL + the 2% guard
- About 0.62 SOL today, shown exactly before you sign
- Guard
- 2% of supply
- Bought in the create, sold into snipers
- Buyback
- 50% of fees
- Buys the coin back and burns it
- Fee sweep
- every 5 min
- One claim per cycle, all on chain
Start
Launch a coin
You sign exactly one thing: a fixed payment to the master. Everything on chain after that is signed by the master.
- 1PrepareName, ticker and picture go through the vamp check. You get back one unsigned transaction: a transfer to the master for the 0.035 SOL fee plus the exact guard cost at pump.fun's fresh-curve price, and a
level:<id>memo. - 2SignYour wallet signs it. The server stores a hash of that exact message and rejects anything else.
- 3ConfirmThe payment is sent. The vamp check runs once more, then the master signs create + guard buy as one transaction.
- 4Refund on failureIf the create would fail or doesn’t land, the payment goes back to your wallet automatically.
- 5Founder buy (optional)Built after the guard, never in block 0, and capped so you can't pass 5% of supply on the curve.
Start
Verify a CA
Every coin here is created by the same master wallet, so "was this launched on level?" has a yes or no answer. Paste a contract address below, in the search bar at the top of every page (press /), or call /api/search.
The answer is yes only if the master created it. .
What we end
Block 0 snipes
With no dev bag, the first buys after a create are free money for bots. So your create and a 2% guard buy are one transaction: they land together, in order, or not at all. The coin address is generated on our server and stays private until it's on chain, so nobody can pre-arm a sniper.
- Block 0MasterCreate + 2% guard buy
One transaction. Lands first, or nothing does.
- Block 0–1SnipersBuy after the guard
Every sniper pays a price the guard already moved.
- Next readGuardSells the 2% into them
Curve read every 250 ms. Sells once outside buyers take tokens.
- AfterHoldersFair curve
No dev bag, no bundle in the launch, fees buy back and burn.
| Rule | Value |
|---|---|
| Guard size | 2% of 1B supply |
| Sells when | curve reserves drop below the starting reserves minus the guard |
| Gives up after | 20 min, then unwinds anyway |
| Master keeps back | 0.04 SOL for gas, rent and refunds |
What we end
Bundles
A bundle is a dev buying the launch from a stack of wallets in the same breath as the create. Here, the create is signed by one master wallet that every coin shares, and the only buy inside it is the guard.
| What a bundle needs | What happens here |
|---|---|
| Buys inside the create transaction | The create holds one buy: the 2% guard, which sells into the next buyers. |
| A dev wallet with a big first bag | No per-coin dev wallet. The master creates every coin and keeps no bag. |
| A founder buy before everyone else | Founder buys are built after the guard and capped at 5% of supply. |
| Hidden linked wallets | The holder check on each coin flags wallets first funded by the same source. |
What we end
Vamps
Ticker and name are folded to one form: case, spacing, Cyrillic and Greek lookalikes and leetspeak all collapse. That form is compared with every coin launched here, and with launches that are paying right now. A match is refused; on anything 4+ letters, one edit away is refused too. Pictures are compared by a 64-bit perceptual hash, 6 bits or fewer apart counts as the same picture. All of it runs before you pay.
Type a name or ticker, including lookalikes like P3PE or PЕPE.
// The exact fold the vamp check uses (lib/vamp.ts).
canon('P3PE') // 'pepe' leetspeak
canon('PЕPE') // 'pepe' Cyrillic Е
canon('P E P E') // 'pepe' spacing
canon('LOL') // 'ioi' l and i are one glyph
collides('pepe', 'pepes') // true — one edit, 4+ letters
collides('dog', 'dogs') // false — too short for the edit ruleAfter launch
Fees + buyback
The master is every coin's creator on pump, so pump pays the creator fee into a bucket per coin. Every 5 minutes one claim sweeps those buckets. The amount booked is read from the claim transaction itself.
- 1Sweep + collectEach coin’s bucket is swept and collected by the master in one transaction.
- 2Split50% is owed back to that coin; the rest funds guards and refunds.
- 3Buy back + burnOnce a coin's guard has sold and it's owed at least 0.003 SOL, the master buys it and burns the exact tokens in the same transaction.
Every step is on the flywheel ledger with its transaction.
After launch
Founder ranks
A rank follows the founder's wallet and climbs with each coin that bonds with a clean record.
| Rank | Bonded coins |
|---|---|
| New | first launch |
| Bronze | 1+ |
| Silver | 2+ |
| Gold | 3+ |
| Platinum | 5+ |
| Diamond | 10+ |
| Champion | 25+ |
After launch
Holder reports
Only holders can report, once per coin. A report counts after 15 minutes if the wallet still holds, weighted by the smaller of the two balances. 5 holders with 5% of supply between them flag the coin.
| Reason id | Meaning |
|---|---|
| dumped | Dumped on holders |
| fake | Fake story or socials |
| copy | Copy of another coin |
| insiders | Insiders hold most of it |
API
Try it live
Plain JSON over HTTPS on this origin. Reads need no key. Amounts are strings in base units: lamports for SOL (1e9) and 6-decimal base units for tokens. Timestamps are ISO 8601 UTC. Press Run to call the real endpoint.
/api/search?q=GNSY6Km1ofFjhsAURpY8fL6CWJJJ5aVQWrMeMZTA6ns2Press Run to call this endpoint for real.
/api/search?q=Paste a contract address and verified is the coin if the master created it, or null. Any other text searches names and tickers launched here. An empty q returns the latest launches. CORS is open, so you can call it from any site or bot.
# A contract address: verified is the coin if the master created it, else null.
curl "https://www.levelpad.app/api/search?q=<mint>"
# A name or ticker: matching coins launched here.
curl "https://www.levelpad.app/api/search?q=pepe"API
Coin data
/api/coins/:mint?kind=…| kind | Returns |
|---|---|
| trades | { trades } — latest 60, indexed from chain |
| candles | { candles } — add tf=1m | 5m | 15m | 1h | 4h |
| market | { marketCapSol, priceSol, progress, complete, realSol } |
| block0 | { blocks } — the first blocks after the create |
| holders | founder bag, top 10, early buyers, linked wallets (60 s cache) |
| fees | { events } — this coin’s flywheel events |
# kind = trades | candles | fees | block0 | market | holders
curl "https://www.levelpad.app/api/coins/<mint>?kind=market"
curl "https://www.levelpad.app/api/coins/<mint>?kind=candles&tf=1m"
curl "https://www.levelpad.app/api/coins/<mint>?kind=block0"API
Flywheel
/api/flywheelSite-wide fee totals, each coin's wheel, when the next sweep runs, and the latest 80 flywheel events.
curl https://www.levelpad.app/api/flywheel/api/activitySite totals and the latest 30 events: collects, buybacks, guard buys and sells.
curl https://www.levelpad.app/api/activityAPI
Launch check
/api/launch/check?name=&symbol=The live vamp check and today's launch cost. vamp is null when the name and ticker are free; master.totalLamports is what a founder pays right now.
curl "https://www.levelpad.app/api/launch/check?name=Pepe&symbol=P3PE"API
Launch
/api/launch/prepare → /api/launch/confirmprepare takes multipart form data (data JSON + image file) and returns { draftId, tx, feeLamports }. confirm takes the signed transaction and returns { mint, signature, slot, founderBuyTx }.
import { VersionedTransaction } from '@solana/web3.js'
// 1. Prepare: the server checks for vamps and builds ONE payment for you to sign.
const fd = new FormData()
fd.append('data', JSON.stringify({
founder: wallet.publicKey.toBase58(),
name: 'Level Cat',
symbol: 'LCAT',
description: 'Launched level.',
founderBuySol: 0.1, // optional, built after the guard
}))
fd.append('image', file) // png / jpg / gif / webp
const prep = await fetch('https://www.levelpad.app/api/launch/prepare', { method: 'POST', body: fd }).then((r) => r.json())
if (prep.error) throw new Error(prep.error) // 409 = vamp, 503 = master refilling
// 2. Sign: ONE transfer to the master (the 0.035 SOL fee + the 2% guard at today's price,
// prep.feeLamports) and a memo. Nothing else.
const tx = VersionedTransaction.deserialize(Buffer.from(prep.tx, 'base64'))
const signed = await wallet.signTransaction(tx)
// 3. Confirm: the server sends it, then the master signs create + 2% guard in one tx.
const done = await fetch('https://www.levelpad.app/api/launch/confirm', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ draftId: prep.draftId, tx: Buffer.from(signed.serialize()).toString('base64') }),
}).then((r) => r.json())
console.log(done.mint, done.signature) // done.founderBuyTx is set if you asked for a founder buyAPI
Report
/api/reportsA wallet-signed message, valid for 10 minutes. Founders can't report their own coin.
import bs58 from 'bs58'
const issuedAt = Date.now()
const message = [
'level holder report',
`coin: ${mint}`,
`wallet: ${wallet}`,
'reason: dumped', // dumped | fake | copy | insiders
`issued: ${issuedAt}`,
].join('\n')
const signature = bs58.encode(await provider.signMessage(new TextEncoder().encode(message)))
await fetch('https://www.levelpad.app/api/reports', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ mint, wallet, reason: 'dumped', issuedAt, signature }),
})API
Errors
Errors are { "error": string } with a matching status. A vamp also returns the coin it collides with.
| Status | When |
|---|---|
| 400 | Bad input: name, ticker, image, unknown kind |
| 401 | Bad or expired signature |
| 403 | Not a holder (reports) |
| 404 | Coin or launch not found |
| 409 | Vamp, duplicate report, or a launch already in progress / refunded |
| 422 | The payment isn’t the one we built, or isn’t signed |
| 429 | Too many launch drafts from this wallet; wait a few minutes |
| 503 | The master is refilling, or a launch is finishing; try again shortly |
{ "error": "That ticker is taken by $PEPE.", "vamp": { "field": "ticker", "mint": "<mint>", "symbol": "PEPE", "name": "Pepe" } }Reference
Constants
| Name | Value | Meaning |
|---|---|---|
| LAUNCH_FEE | 0.035 SOL | Fee on top of the guard cost |
| GUARD | 2% | Share of supply bought in the create, paid by the founder |
| GUARD_MAX_HOLD | 20 min | Guard unwinds after this if nobody buys |
| FOUNDER_CAP | 5% | Largest founder buy we build on the curve |
| BUYBACK | 50% | Share of creator fees that buys + burns |
| MIN_BUYBACK | 0.003 SOL | Smallest buyback we send |
| FEE_CYCLE | 5 min | How often fees are swept |
| FLAG | 5 holders · 5% | What it takes to flag a coin |
Reference
FAQ
Why do I pay for the guard?
The 2% guard is bought inside your create at pump.fun’s fresh-curve price. Your payment covers it, so no launch waits on our wallet. If pump’s price moves and the guard would cost more than you paid, the launch stops and your payment is refunded.
Can someone still snipe block 1?
Yes, nobody can stop a buy. What changes is the trade: the guard sells its 2% into the first outside buyers, so a sniper buys the top instead of the bottom.
Can a founder bundle with other wallets after launch?
Nobody can put buys inside the launch transaction, and we won’t build a founder buy past 5%. After that, anyone can buy from any wallet, so the holder check on each coin flags wallets funded by the same source.
Someone copied a ticker on pump.fun. Is that a vamp?
The vamp check covers coins launched here. A copy made directly on pump.fun isn’t created by the master, so pasting its CA into Verify says “Not launched on level”.
Where do creator fees go?
The master is the creator on pump, so fees land in a bucket per coin. Every 5 minutes they’re swept; 50% buys that coin back and burns it, the rest funds future guards and refunds.
What happens if the launch fails?
If the create would fail or doesn’t land, your payment is sent back to the same wallet automatically. Stuck launches are retried or refunded by the minute job.
Reference
Limits + trust
- The master wallet is custodial for fees and the guard: it signs creates, guard trades, claims and burns. Every one of them is on chain.
- Founders hold their own keys, so the founder cap is a build rule, not an on-chain one. The holder check shows what they hold.
- The vamp check covers coins launched here. Copies made directly on pump.fun aren’t blocked, but Verify will say they didn’t launch here.
- Pump.fun sets the trading fee and keeps its protocol share. Its takeover (CTO) admin can reassign any pump coin’s creator fees.
- Linked wallets are found one step back. A clean holder check is evidence, not proof.
- Not affiliated with pump.fun.