SPLICE

Launch API · v1

SPLICE coins,
from your site.

Launch coins that run on the SPLICE engine without sending your users anywhere. AI fund managers that decide what the fees do, burns, holder payouts, games and a mind that thinks in public, all set in one call and live from the first trade.

<script src="https://splicepad.com/sdk/splice.js"></script>
API launches
0
Live coins
0
Partner sites
0
Programs + AI models
39 + 9
Example run: a partner site launches a SPLICE coin with an AI Fund Manager through the API.
your-site.com/launch

Your site, your design

Moon Cat
$MCAT
AI Fund ManagerClaude Sonnet 5.5"Burn hard on red days, pay holders when volume is up."
Launch on Pump.fun
  1. Prepare
  2. Sign
  3. Relay
  4. Live
network · splicepad.comexample run
  1. Waiting for a launch…

What every coin gets

Our tech, inside your product.

The API isn't a bare token launcher. Every coin it creates carries the same engine as splicepad.com, configured by you in the launch spec.

The headline feature

AI fund managers

Hand a coin's fees to a frontier model. Every hour it reads the chart, the buy and sell flow and the launcher's rules, then decides what the fees do. The engine clamps it to hard limits, executes on chain and publishes the reason on the coin page.

  • AI Fund Managerai_manager

    A model you pick reads the market every hour and decides how much to burn, pay holders, keep or pay you.

  • AI Dip Buyerai_dip

    Fees pile up while a model watches the chart. It fires the buyback and burn when it sees a dip.

  • AI Dividend Pickerai_dividend

    Every hour a model picks which asset holders are paid in: SOL, BTC, ETH, USDC, JUP, BONK or WIF.

  • AI Judgeai_judge

    A model reviews every buyer in the window and awards the pot to the best trade, with a written verdict.

9 models to choose from

  • Claude Opus 5.5
  • Claude Sonnet 5.5
  • GPT-6.1 Sol
  • Grok 4.7
  • Gemini 3.8 Flash
  • DeepSeek V4.1 Flash
  • GPT-6 Luna
  • Qwen3.8 Flash
  • GLM 5.3

How it works

Three calls. One signature.

  1. 1

    Prepare

    POST /api/v1/launch/prepare

    Send the coin plus its spec: which AI manager or programs run the fees, which model, the rules, the split. SPLICE validates it and builds the exact transactions.

  2. 2

    Sign

    wallet.signAllTransactions

    Your user approves once in their own wallet. They are the creator on Pump.fun; SPLICE never touches a private key.

  3. 3

    Run

    POST /api/v1/launch/confirm

    SPLICE verifies and relays. From the first trade the coin is on the SPLICE engine: its AI manager decides, its programs execute, its proofs are public.

Quickstart

Drop it into any page.

Plain HTML or your React app. The SDK loads web3.js only when it needs it.

<script src="https://splicepad.com/sdk/splice.js"></script>

<form id="launch">
  <input name="name" placeholder="Name" required />
  <input name="symbol" placeholder="Ticker" required />
  <input name="image" type="file" accept="image/*" required />
  <button>Launch on Pump.fun</button>
  <p id="status"></p>
</form>

<script>
  document.getElementById('launch').addEventListener('submit', async (e) => {
    e.preventDefault()
    const f = new FormData(e.target)
    const status = document.getElementById('status')
    try {
      const coin = await Splice.launch({
        name: f.get('name'),
        symbol: f.get('symbol'),
        image: f.get('image'),
        ref: 'my-site',
        onStep: (step) => (status.textContent = step + '…'),
      })
      status.innerHTML = '<a href="' + coin.url + '">Live: $' + f.get('symbol') + '</a>'
    } catch (err) {
      status.textContent = err.message
    }
  })
</script>

Snippet builder

Hire the AI. Copy the code.

Pick a program, a model and the rules it follows; the launch snippet updates as you go.

Style

The model follows these; hard limits are enforced by code.

80% program · 20% creator

80% of the split runs AI Fund Manager. On SOL pairs the split covers 90% of fees; 10% buys back $SPLICE.

Saved with every coin next to your domain.

launch.html
<script src="https://splicepad.com/sdk/splice.js"></script>
<script type="module">
  const coin = await Splice.launch({
    name: 'Moon Cat',
    symbol: 'MCAT',
    image: file, // File, Blob or an https URL
    ref: 'my-site',
    spec: {
      pkg: 'custom',
      creatorBps: 2000,
      extensions: [{
        id: 'ai_manager',
        weight: 8000,
        config: {
          model: 'anthropic/claude-sonnet-5.5',
          rules: 'Burn hard on red days, pay holders when volume is up, never pay me more than 5%.',
        },
      }],
    },
    onStep: (step) => console.log(step),
  })
  console.log('Live:', coin.url)
</script>

Reference

Endpoints

All endpoints accept requests from any origin. No key, no account.

  • POST/api/v1/launch/prepare

    Build a launch

    JSON (imageUrl or imageBase64 + imageType) or multipart (image file + data JSON). Returns mint, sign order and base64 txs.

    8/min
  • POST/api/v1/launch/confirm

    Verify and relay

    Body: { mint, txs } signed by the launcher. Safe to resend if the connection drops.

    12/min
  • GET/api/v1/coins/[mint]

    Launch status

    pending until the create transaction lands, then live, with SPLICE and Pump.fun links.

    60/min
  • GET/sdk/splice.js

    Browser SDK

    Splice.launch(opts) and Splice.status(mint). Plain JS, drops into any stack.

Without the SDK

import { VersionedTransaction } from '@solana/web3.js'

const SPLICE = 'https://splicepad.com'
const b64 = (s: string) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0))
const toB64 = (u: Uint8Array) => btoa(String.fromCharCode(...u))

// 1. Prepare: SPLICE screens the image, pins metadata and builds the transactions.
const prepared = await fetch(`${SPLICE}/api/v1/launch/prepare`, {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({
    name: 'Moon Cat',
    symbol: 'MCAT',
    description: 'Fees burn the supply.',
    imageUrl: 'https://example.com/cat.png',
    launcher: wallet.publicKey.toBase58(),
    spec: { pkg: 'custom', creatorBps: 5000, extensions: [{ id: 'buy_burn', weight: 5000 }] },
    ref: 'my-site',
  }),
}).then((r) => r.json())

// 2. One wallet approval for every transaction, in the order given by `sign`.
const signed = await wallet.signAllTransactions(
  prepared.sign.map((k: string) => VersionedTransaction.deserialize(b64(prepared.txs[k]))),
)
const txs = Object.fromEntries(prepared.sign.map((k: string, i: number) => [k, toB64(signed[i].serialize())]))

// 3. Confirm: SPLICE checks the signed bytes match what it built, then relays them.
const coin = await fetch(`${SPLICE}/api/v1/launch/confirm`, {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ mint: prepared.mint, txs }),
}).then((r) => r.json())

console.log(coin.url, coin.pumpUrl)

Errors

  • 400
    Bad inputMissing name, bad ticker, unknown program id, or a file that isn’t an image.
  • 422
    RefusedImage flagged by the safety check, or signed transactions that don’t match what prepare built.
  • 429
    Rate limitedPrepare 8/min, confirm 12/min, status 60/min, per visitor IP.
  • 503
    Try againThe image check or the network is briefly unavailable. Nothing was created.

Errors come back as { error: string } with a sentence you can show to the user as is.

Try it

Hit the live endpoint.

This sends a real request to the live endpoint. The field is filled with the newest coin on SPLICE; paste any mint you got back from prepare.

What you get

Built so you don’t have to trust us.

  • The full engine, not a lite version

    Coins launched from your site run on the same hourly and minute cycles, AI models and payout rails as coins launched on splicepad.com.

  • Non-custodial launches

    The launcher signs every transaction in their own wallet. No keys, no deposits, no accounts on SPLICE.

  • Every decision is public

    AI verdicts, burns, payouts and their transaction signatures are listed on each coin’s SPLICE page, so your users can check the work.

  • Credited to your site

    Each coin stores the domain it was launched from and your ref, so launches from your site are on record.

Partners

Sites launching SPLICE coins

No partner launches yet.

The first site to launch a coin through the API shows up here.

Get the snippet

Spread the word

Announce it with a card.

The Launch API card is in the card studio: edit the headline, pick the AI program and model in the snippet, and post it in wide, square or story format.

Open the card studio
Launch API announcement card

FAQ

Questions

Which SPLICE features work through the API?
Every fee program, including the four AI programs with any of the supported models and your own rules, plus coin minds (brain), native payout chains and fee splits with wallets. Studio characters are the one thing that stays on splicepad.com.
Who pays for the AI?
SPLICE runs the models. Neither you nor the launcher needs an AI provider key.
Do I need an API key?
No. The API is open to every origin. Every launch needs the launcher’s own wallet signature, so there is nothing to abuse with a key.
Who is the creator of the coin?
The visitor whose wallet signed. They show as the creator on Pump.fun and get the creator share of the fee split.
Can I take a cut of the fees?
Yes: add your wallet to the fee spec as a recipient, the same way the launch page lets anyone split fees with a wallet. The launcher sees the split before they sign.
Does it work with my wallet adapter?
Pass any object with publicKey and signAllTransactions to Splice.launch. Without one, the SDK connects Phantom, Solflare or Backpack itself.
What does the coin’s Pump.fun page link to?
Its SPLICE page, where its programs, payouts and on-chain proofs are listed. That link is pinned in the metadata and can’t change.

More detail in the docs.