Programs, API, and launch reference.

Every Balloon coin is created by one wallet on pump.fun's own programs. Every launch, from any page of this site, goes through this wallet.

Balloon launch walletReceives the 0.1 SOL launch payment and creates every coin, so it is every coin's creator on pump.fun and receives its creator fees.

not set yet

pump.funCreates every Balloon coin and runs its bonding curve.

6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6PCopySolscan ↗

PumpSwappump.fun's own pool program, where a coin trades after it graduates.

pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEACopySolscan ↗

Solana programs and accounts Balloon builds on

System programMoves the 0.1 SOL launch payment from the launcher to the launch wallet.

11111111111111111111111111111111CopySolscan ↗

Memo programCarries the memo that ties each launch payment to its launch.

MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHrCopySolscan ↗

Wrapped SOLThe SOL side of a coin's PumpSwap pool.

So11111111111111111111111111111111111111112CopySolscan ↗

Balloon has no exchange of its own. A coin trades on pump.fun's bonding curve from the moment it is created, then on PumpSwap once the curve fills, and through Jupiter and trading apps at either stage.

Every Balloon coin starts on pump.fun's bonding curve and moves to PumpSwap when the curve fills.

A launch is one payment the launcher signs and one create the launch wallet signs. The coin is only created after the payment is proven on chain; if the create then cannot happen, the payment goes to a refund list.

1. 01

   Check

   GET /api/launch/status says whether launching is open, the price (0.1 SOL), and the launch wallet the payment goes to. While it is closed, nothing can be paid for.

2. 02

   Sign in

   The launcher's wallet signs a message (POST /api/auth). Nothing is paid and no transaction is sent.

3. 03

   Prepare

   POST /api/launch/prepare stores the picture and the coin's metadata, fixes the coin's mint address, and returns an unsigned payment: one transfer of exactly 0.1 SOL to the launch wallet with the memo balloon launch <id>.

4. 04

   Sign the payment

   The page checks the transaction is exactly that payment, then the wallet signs it without sending. POST /api/launch/submit sends it.

5. 05

   Prove the payment

   Before any coin is made, the server reads the confirmed payment back from the chain: the launcher paid, the launch wallet's balance rose by exactly 0.1 SOL, and the memo is there.

6. 06

   Create the coin

   The launch wallet creates the coin on pump.fun through PumpPortal, with no dev buy, and pays pump.fun's create cost (about 0.02 SOL) out of the fee. Every retry uses the same mint, so one launch can never make two coins.

7. 07

   Go live

   The page asks POST /api/launch/confirm every 2 to 3 seconds. The coin is live once the chain proves the create, and it appears on Balloon, usually within seconds.

8. 08

   Optional pre-buy

   If the launcher asked for one, the page builds their own buy (POST /api/trade/build), and their wallet signs and sends it. It is not paid to Balloon.

The picture and the metadata are stored in Balloon's Supabase storage, and the coin's on-chain metadata link points there. If the launch wallet is low on SOL, a paid launch waits and is created as soon as it is topped up.

You do not need the Balloon API to follow its coins. Every Balloon coin is an ordinary pump.fun coin whose creator is the launch wallet, so its accounts are found like any pump.fun coin's. The samples below use @solana/web3.js, with mint and launchWallet as PublicKeys.

import { PublicKey } from "@solana/web3.js";

const PUMP = new PublicKey("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P");
const PUMP_SWAP = new PublicKey("pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA");
const WSOL = new PublicKey("So11111111111111111111111111111111111111112");
const seed = (s: string) => Buffer.from(s, "utf8");

// The coin's bonding curve (it also holds the curve's tokens)
const [curve] = PublicKey.findProgramAddressSync([seed("bonding-curve"), mint.toBuffer()], PUMP);

// The PumpSwap pool the coin graduates into
const [poolAuthority] = PublicKey.findProgramAddressSync([seed("pool-authority"), mint.toBuffer()], PUMP);
const [pool] = PublicKey.findProgramAddressSync(
  [seed("pool"), Buffer.from([0, 0]), poolAuthority.toBuffer(), mint.toBuffer(), WSOL.toBuffer()],
  PUMP_SWAP,
);

// pump.fun keeps the creator fees of every Balloon coin here until they are claimed
const [creatorVault] = PublicKey.findProgramAddressSync([seed("creator-vault"), launchWallet.toBuffer()], PUMP);

program  MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr
memo     balloon launch <launch id>

JSON over HTTPS for coins launched on Balloon, with prices, volume, trades, holders, and candles from Balloon's own index. Reads need no key or signup.

• Call it from your server. Responses carry no CORS headers, so a browser fetch from another site is blocked.
• Read answers are cached for up to 15 seconds, so polling more often returns the same data. Server errors are never cached.
• Only coins launched on Balloon and proven live on chain appear. Drafts, failed launches, and other pump.fun coins never do.
• The API is not versioned. Fields may be added, so ignore unknown keys and expect null values.

curl "<this site>/api/coins?order=NEWEST&limit=25"

{
  "items": [ { /* Coin, see API data */ } ],
  "nextCursor": "<opaque>"   // null on the last page
}

curl "<this site>/api/coins/<mint>"

{ /* Coin, see API data */ }   // 404 { "error": "No such coin here." } when not launched on Balloon

curl "<this site>/api/coins/<mint>/trades?limit=50"

{
  "items": [ { /* Trade */ } ],   // newest first
  "nextCursor": "<opaque>"
}

curl "<this site>/api/coins/<mint>/holders"

{ "holders": [ { /* Holder */ } ] }   // top 20 of the newest snapshot

curl "<this site>/api/coins/<mint>/candles?res=300&limit=300"

{ "candles": [ { /* Candle */ } ] }   // oldest first, USD

curl "<this site>/api/search?q=<name, ticker or mint>"

{ "coins": [ { /* Coin */ } ] }   // at most 6

curl "<this site>/api/sol-price"

{ "usd": <number> }

curl "<this site>/api/stats"

{ "coins": <number>, "trades": <number>, "traders": <number> }

curl "<this site>/api/events/recent?limit=20"

{ "trades": [ { /* Trade, with its coin */ } ] }

curl "<this site>/api/launch/status"

{
  "open": <true or false>,
  "reason": "<plain words while closed, else null>",
  "feeSol": 0.1,
  "createCostSol": 0.02,   // paid by the launch wallet out of the fee
  "totalSol": 0.1,
  "launchWallet": "<address or null>"
}

Errors and limits

Coin fields

Market data

Prices come from the newest indexed trade or market read, times the current SOL price. A number nobody has measured yet is null, never a guess.

Trades, holders, and candles

Balloon reads every live coin's trades every minute and takes holder snapshots every 10 minutes. A busy coin can take a few minutes to catch up, so show times and prefer the chain when it matters.

type Trade = {
  id: string;            // "<signature>:<event index>"
  direction: "BUY" | "SELL";
  solAmount: number;
  tokenAmount: number;
  timestamp: string;     // ISO 8601
  signature: string;
  trader: Person;
  isDeployer: boolean;   // the launcher's own trade
  coin?: { mint: string; symbol: string; imageUrl: string | null; imageFlag: "NSFW" | null };
};

type Holder = {
  owner: Person;
  amount: number;
  percentage: number;    // of total supply
  label: "BONDING_CURVE" | "POOL" | "DEV" | null;   // DEV = the launcher
};

type Candle = { time: number; open: number; high: number; low: number; close: number; volume: number };
// time in unix seconds; prices and volume in USD

type Person = {
  address: string;       // a Solana wallet
  twitterUsername: string | null;   // always null: no X linking
  twitterName: string | null;
  twitterProfileImageUrl: string | null;
};

Displaying coin data safely

• Names, tickers, and descriptions are arbitrary user input. Escape them and never inject them as HTML.
• Tickers are not unique and impersonation is common. Show the mint address next to the name.
• Balloon accepts only JPEG, PNG, and GIF pictures. Still never render SVG from any token source; it can carry script.
• websiteUrl, twitterUrl, and telegramUrl are supplied by the launcher. If you make them clickable, use rel="noopener noreferrer nofollow".
• Link each coin to /token/<mint> and credit the source as “Coin data from Balloon”.

Balloon has no SDK. The read API above and the chain are the supported ways to build on Balloon coins, and launches go through the Launch page.

• The launch routes (POST /api/launch/prepare, submit, and confirm) serve this site's own pages. They need a signed-in wallet session and the x-balloon: balloon header, refuse requests from other sites, and may change at any time.
• Sign-in (POST /api/auth) and the trade builder (POST /api/trade/build) are internal routes of the same kind, not a public API.
• Every Balloon coin is a normal pump.fun coin, so any tool that reads or trades pump.fun coins works with it.
• Balloon never holds a launcher's keys. Every launch payment is signed in the launcher's own wallet.