Documentation
SPLICE launches a coin on Pump.fun and builds programs into its creator fee: burn, pay holders, lotteries, AI managers, custom recipes. Everything here is backed by a public API you can call right now.
Live API console
Real requestsPick an endpoint and send a request. The response appears here.
A normal Pump.fun coin, with one change: its creator fees have a job.
Every trade on Pump.fun pays a small creator fee. Normally it all goes to whoever launched the coin. On SPLICE you write a fee spec at launch: keep some, send some to any wallet, and hand the rest to programs that burn supply, pay holders, run lotteries or let an AI decide. Every action is an on-chain transaction listed on the coin's page.
The coin trades on Pump.fun exactly like any other: same bonding curve, same graduation. Only where the creator fee ends up is different.
Two requests and one wallet approval. Click any step to inspect it.
Launch sequence
Step 1Send name, ticker, image and your fee spec. The server pins metadata to IPFS and derives the coin’s fee wallet.
fetch("/api/launch/prepare", { method: "POST", body })import { VersionedTransaction } from '@solana/web3.js'
const API = 'https://splicepad.com'
const wallet = window.phantom.solana // any wallet with signAllTransactions
// 1. Describe the coin and what its fees do.
const form = new FormData()
form.append('image', file) // PNG, JPG, GIF or WebP, under 3.5 MB
form.append('data', JSON.stringify({
name: 'Burn Machine',
symbol: 'BURN',
description: 'Every trade buys the coin back and burns it.',
launcher: wallet.publicKey.toBase58(),
spec: {
quoteMint: 'So11111111111111111111111111111111111111112',
pkg: 'extensions',
extensions: [{ id: 'buy_burn', weight: 10000, config: { burnBps: 100 } }],
buySol: 0.1,
},
}))
// 2. The server builds the transactions.
const prepared = await fetch(`${API}/api/launch/prepare`, { method: 'POST', body: form })
if (!prepared.ok) throw new Error((await prepared.json()).error)
const { mint, txs } = await prepared.json()
// 3. One approval signs all of them.
// feeShare / buy are null when the spec doesn't need them
const roles = (['create', 'feeShare', 'buy'] as const).filter((r) => txs[r])
const unsigned = roles.map((r) => VersionedTransaction.deserialize(Buffer.from(txs[r], 'base64')))
const signed = await wallet.signAllTransactions(unsigned)
// 4. The server verifies and relays them in order.
const body = { mint, txs: Object.fromEntries(roles.map((r, i) => [r, Buffer.from(signed[i].serialize()).toString('base64')])) }
const confirmed = await fetch(`${API}/api/launch/confirm`, {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify(body),
}).then((r) => r.json())
console.log(`Live: ${API}/token/${confirmed.mint}`, confirmed.feeShare) // "shared"One object decides where every lamport of creator fee goes. Drag the sliders.
Programs share one Pump.fun shareholder slot, so you can stack as many as you like behind it.
{
"spec": {
"quoteMint": "So11111111111111111111111111111111111111112",
"pkg": "custom",
"creatorBps": 2000,
"potBps": 7000,
"wallets": [
{
"address": "<PARTNER_WALLET>",
"bps": 1000
}
],
"extensions": [
{
"id": "buy_burn",
"weight": 4200,
"config": {
"burnBps": 100
}
},
{
"id": "earn_sol",
"weight": 2800,
"config": {}
}
],
"buySol": 0.25
}
}Written into Pump.fun's fee-sharing config
<YOUR_WALLET>2000 bps<FEE_WALLET>7000 bps<PARTNER_WALLET>1000 bpspkg picks the shape: creator (everything to you), holders (Pump.fun's native holder rewards), extensions (everything to programs) or custom. In a custom spec, creatorBps, each wallet's bps and every program's weight are basis points of all fees and must add up to 10,000.
{
"quoteMint": "So11111111111111111111111111111111111111112",
"pkg": "extensions",
"extensions": [
{ "id": "buy_burn", "weight": 10000, "config": { "burnBps": 100 } }
],
"buySol": 0
}Routing is done by Pump.fun itself, not by a promise from us.
Pump.fun has a native fee-sharing config: a per-coin account listing who receives the creator fee. At launch the config is created with your shareholders, and Pump.fun pays them on every distribution.
Programs
One slot → the coin's fee wallet
All programs share a single shareholder slot. The engine collects into it and splits the pot by weight.
You and wallets
Paid straight from Pump.fun
Your share and partner wallets are written into the config. SPLICE never holds these fees.
At five past every hour, each live coin runs one cycle. Recipes tick every minute.
| Schedule | Hourly at :05 · recipes every minute |
|---|---|
| Minimum collect | 0.005 SOL |
| Reserve kept | 0.008 SOL Pays transaction fees and token-account rent. |
| Minimum to act | 0.02 SOL |
| Swaps | Jupiter Buybacks allow up to 5% slippage. |
Every program and the exact rule the engine applies. Filter, search, launch.
30 of 30 programs
Creator fees are paid out to holders in SOL.
{ "id": "earn_sol" }Launch with itCreator fees are swapped to cbBTC and paid out to holders.
{ "id": "earn_btc" }Launch with itCreator fees are swapped to ZEC and paid out to holders.
{ "id": "earn_zec" }Launch with itCreator fees are swapped to USDC and paid out to holders.
{ "id": "earn_usdc" }Launch with itCreator fees buy the token back and burn it.
{ "id": "buy_burn" }Launch with itCreator fees accumulate and buy the floor of an NFT collection.
{ "id": "nft_sweep" }Launch with itEvery cycle, fees are swapped into one asset and sent to a wallet.
{ "id": "dca" }Launch with itFees build a pot. One holder wins it, weighted by balance.
{ "id": "lottery" }Launch with itFees are split between up to 10 wallets, enforced by Pump.fun itself.
{ "id": "split" }Launch with itFees are collected into a treasury, part held in SOL and part in USDC.
{ "id": "treasury" }Launch with itCreator fees are swapped to ETH and paid out to holders.
{ "id": "earn_eth" }Launch with itCreator fees are swapped to JUP and paid out to holders.
{ "id": "earn_jup" }Launch with itCreator fees are swapped to BONK and paid out to holders.
{ "id": "earn_bonk" }Launch with itCreator fees are swapped to WIF and paid out to holders.
{ "id": "earn_wif" }Launch with itOnly the biggest holders get paid — the top N wallets share the fees in SOL.
{ "id": "whale_club" }Launch with itFees build a pot, then several holders win an equal slice of it.
{ "id": "raffle" }Launch with itEvery cycle, all fees are streamed in SOL to one wallet — a charity, a DAO, a dev fund.
{ "id": "stream" }Launch with itOne cycle, two outcomes: part of the fees burns supply, part pays holders in SOL.
{ "id": "combo" }Launch with itEvery holder above the minimum gets the exact same SOL, whatever the size of their bag.
{ "id": "flat_dividend" }Launch with itOnly the small holders get paid. Whales are excluded by rule.
{ "id": "shrimp_fund" }Launch with itThe wallet that bought the most in the window takes the whole pot.
{ "id": "top_buyer" }Launch with itA countdown that every buy resets. When nobody buys before it hits zero, the last buyer takes the pot.
{ "id": "last_buyer" }Launch with itFees buy the token and lock it in the program wallet, which has no sell instruction.
{ "id": "buy_vault" }Launch with itFees buy a different coin and burn it. Tribute, rivalry or alliance.
{ "id": "cross_burn" }Launch with itEvery hour, fees are spread across BTC, ETH, USDC and SOL and sent to one wallet.
{ "id": "index_fund" }Launch with itThe creator takes a fixed daily salary. Everything above it buys the coin and burns it.
{ "id": "salary_cap" }Launch with itA model you pick reads the market every hour and decides how much to burn, pay holders, keep or pay you.
{ "id": "ai_manager" }Launch with itFees pile up while a model watches the chart. It fires the buyback and burn when it sees a dip.
{ "id": "ai_dip" }Launch with itEvery hour a model picks which asset holders are paid in: SOL, BTC, ETH, USDC, JUP, BONK or WIF.
{ "id": "ai_dividend" }Launch with itA model reviews every buyer in the window and awards the pot to the best trade, with a written verdict.
{ "id": "ai_judge" }Launch with itA model reads the market and decides. Code enforces the limits.
4 programs hand one decision to a model you pick: how to split the pot, when to buy a dip, which asset to pay holders in, or who won a buying contest. The model only ever returns a choice. Amounts, destinations and caps are enforced in code, and any answer outside the allowed set is rejected.
Every run is recorded as a session: the data fetched, the exact brief and prompt the model read, its raw answer with timing, and what was executed. The coin page replays it; the API returns it.
curl "https://splicepad.com/api/tokens/<MINT>/thoughts"Wire your own program from blocks: When → If → Do.
A recipe is a graph. Triggers start it, conditions and logic route the value, and actions spend it. Build one on the recipe canvas, describe it in English and let the AI draw it, or send the JSON yourself. Every recipe can be replayed on a real coin's last week first.
{
"version": 1,
"nodes": [
{ "id": "t", "type": "schedule", "data": { "minutes": 60 } },
{ "id": "s", "type": "split", "data": { "ways": 2, "a": 70, "b": 30 } },
{ "id": "dip", "type": "if", "data": { "match": "all", "clauses": [
{ "metric": "price_change", "op": "lt", "value": -10, "window": 60 }
] } },
{ "id": "buy", "type": "buy", "data": { "target": "self" } },
{ "id": "burn", "type": "burn", "data": {} },
{ "id": "pay", "type": "distribute", "data": {} }
],
"edges": [
{ "id": "e1", "source": "t", "sourceHandle": "out", "target": "s" },
{ "id": "e2", "source": "s", "sourceHandle": "a", "target": "dip" },
{ "id": "e3", "source": "dip", "sourceHandle": "yes", "target": "buy" },
{ "id": "e4", "source": "buy", "sourceHandle": "out", "target": "burn" },
{ "id": "e5", "source": "s", "sourceHandle": "b", "target": "pay" }
]
}| Triggers | Every, On trades, Fees reach, Market cap crosses, Price drops, Price pumps, New all-time high, Volume exceeds, Holders reach, Graduates, Buy pressure, Wallet trades, Webhook |
|---|---|
| Conditions | If, Ask AI |
| Logic | Split, Cap, Cooldown, First X, then |
| Actions | Send, Buy, Burn, Keep, Pay holders, Lottery, Run program, Notify |
A webhook trigger fires its branch when your server calls it, so anything off-chain (a game result, a sales milestone, a vote) can spend fees. The key is shown only to the creator on the coin page.
curl -X POST "https://splicepad.com/api/hooks/<MINT>/<NODE_ID>" \
-H "x-splice-key: <KEY_FROM_COIN_PAGE>"| Immutable | The recipe is frozen at launch, forever. |
|---|---|
| Timelocked | The creator can change it; every change waits 24 hours in public first. |
| Multisig | Changes need M of N signer wallets to approve. |
| Creator editable | The creator can change it instantly. Fastest, least trust. |
How holder programs decide who gets what. Drag the sliders.
Each cycle reads every wallet holding the token, skips the bonding curve, the fee wallet and anyone below the coin's minimum holding, and splits the amount in proportion to balance.
Credits go into a ledger rather than thousands of hourly transfers, which would burn the rewards on network fees. They add up until you claim.
| Wallet | Holding | Share | Credited |
|---|---|---|---|
| Bonding curve | 612,000,000 | skipped · curve | — |
| 7xKp…a91Q | 38,000,000 | 57.45% | 0.689342 SOL |
| Hn2c…Rt4v | 21,500,000 | 32.50% | 0.390023 SOL |
| Module wallet | 9,000,000 | skipped · module wallet | — |
| 4bWe…p0Lm | 6,200,000 | 9.37% | 0.112472 SOL |
| Qz8u…Ke3s | 450,000 | 0.68% | 0.008163 SOL |
| Dd1r…Yy7n | 80,000 | skipped · below minimum | — |
Example wallets. 4 of 7 addresses qualify; payouts are rounded down to the smallest unit, so the module never credits more than it holds.
Prove you own the wallet with a signed message. The fee wallet pays the network fee.
import bs58 from 'bs58'
const time = new Date().toISOString()
const message = [
'SPLICE claim',
`mint: ${mint}`,
`wallet: ${wallet}`,
`asset: ${asset}`, // SOL | BTC | ZEC | USDC
`time: ${time}`,
].join('\n')
const { signature } = await window.phantom.solana.signMessage(
new TextEncoder().encode(message),
'utf8',
)
const res = await fetch('https://splicepad.com/api/claim', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ mint, wallet, asset, time, signature: bs58.encode(signature) }),
})
console.log(await res.json())curl "https://splicepad.com/api/claim?wallet=<YOUR_WALLET>"| Minimum SOL | 0.001 SOL |
|---|---|
| Minimum cbBTC | 0.00001 cbBTC |
| Minimum ETH | 0.00001 ETH |
| Minimum ZEC | 0.001 ZEC |
| Minimum USDC | 0.1 USDC |
| Minimum JUP | 0.1 JUP |
| Minimum BONK | 100 BONK |
| Minimum WIF | 0.1 WIF |
The draw is seeded by the chain, not by us.
When a draw is due, eligible holders are snapshotted (the launch wallet is excluded) and a recent finalized blockhash is taken. sha256(blockhash:mint) picks the wallet where that number lands on the stacked balances. One ticket per token.
The blockhash, winner and entrant count are logged with the payout, so anyone can re-run the draw.
import { createHash } from 'node:crypto'
// The lottery event records the seed blockhash, the winner and the entrant count.
// Rebuild the eligible holders (wallet + raw token amount) at the draw's slot,
// in the same order, and the same seed must land on the same winner.
function pick(holders: { owner: string; amount: bigint }[], blockhash: string, mint: string) {
const supply = holders.reduce((s, h) => s + h.amount, 0n)
const digest = createHash('sha256').update(`${blockhash}:${mint}`).digest('hex')
const r = BigInt('0x' + digest) % supply
let acc = 0n
for (const h of holders) {
acc += h.amount
if (r < acc) return h.owner
}
}What is enforced by Pump.fun, and what runs on our servers.
Enforced on chain
Run by SPLICE
Public, keyless JSON. Amounts are strings in base units. Errors are { error: string }.
/api/launch/prepareBuild a launch
Multipart: image file + data JSON (name, symbol, description, launcher, spec, links).
/api/launch/confirmVerify and relay
Body: { mint, txs: { create, feeShare?, buy? } } signed, base64.
/api/quotesQuote pairs
Every mint Pump.fun accepts as a curve quote, with metadata.
/api/tokens/[mint]/tradesRecent trades
Latest 40 trades for any Pump.fun coin.
/api/tokens/[mint]/candles?tf=Price candles
1m, 5m, 15m, 1h, 4h or 1d. SPLICE coins only.
/api/tokens/[mint]/position?wallet=A wallet’s position
Holdings and rewards for one coin.
/api/tokens/[mint]/thoughtsAI sessions
Recorded runs of the coin’s AI programs.
/api/tokens/[mint]/recipeRecipe + governance
The live graph, policy and pending proposals.
/api/recipes/compileEnglish → recipe
Body: { prompt, model? }. Returns a validated graph.
/api/recipes/backtestReplay a recipe
Runs a graph over a real coin’s recent candles.
/api/hooks/[mint]/[node]Fire a webhook trigger
Header x-splice-key or ?key=.
/api/claim?wallet=Claimable balances
Per token and asset. Add &mint= for one token.
/api/claimClaim
Body: mint, wallet, asset, time, signature (base58).
curl "https://splicepad.com/api/tokens/<MINT>/trades"
curl "https://splicepad.com/api/tokens/<MINT>/candles?tf=5m" # 1m 5m 15m 1h 4h 1dThe numbers that shape every launch and payout.
| Ticker | 2–10 letters or numbers |
|---|---|
| Image | PNG, JPG, GIF or WebP, under 3.5 MB |
| Initial buy | 0 – 10 SOL |
| Fee wallet fuel | 0.01 SOL Paid by the launcher, used by programs for network fees. |
| Pump.fun shareholders | Up to 10 All programs share one slot, so you can stack as many as you like. |
| Lottery interval | 1 – 168 hours |
| Rate limits | Per IP, see API reference |