Create Token on Pump.fun

Launch tokens on pump.fun programmatically using our token creation API. Create pump.fun tokens with optional dev buys, or use Jito bundles for atomic multi-wallet launches. This is the client-side flow — you sign every transaction yourself. If you want a one-call launch with no signing or IPFS upload, use Lightning Create instead.

PumpDev supports both native-SOL and non-native quote mints when creating coins. For SOL pairs, omit quoteMint and continue using buyAmountSol. For USDC or other SPL quote pairs, pass quoteMint and use buyAmountQuote / amountQuote values in quote-token units.

API Endpoints

Endpoint	Description
POST /api/create	Create pump.fun token (optional dev buy)
POST /api/create-bundle	Pump.fun Jito bundle - atomic multi-buyer launch

---

Step 1: Upload Metadata to IPFS

Before creating your token, upload metadata to IPFS or another public metadata host. The old https://pump.fun/api/ipfs endpoint is no longer supported, so this example uses Pinata. Create a Pinata account, copy your JWT, and set it as PINATA_JWT.

const PINATA_JWT = process.env.PINATA_JWT;

async function uploadMetadata() {
  if (!PINATA_JWT) throw new Error('PINATA_JWT is required');

  // 1. Upload token image
  const logoRes = await fetch('https://pumpdev.io/img/logo.jpg');
  const logoBuffer = await logoRes.arrayBuffer();
  const imageForm = new FormData();
  imageForm.append('file', new Blob([logoBuffer], { type: 'image/jpeg' }), 'logo.jpg');

  const imageRes = await fetch('https://api.pinata.cloud/pinning/pinFileToIPFS', {
    method: 'POST',
    headers: { Authorization: `Bearer ${PINATA_JWT}` },
    body: imageForm,
  });
  const image = await imageRes.json();
  if (!imageRes.ok) throw new Error(JSON.stringify(image));

  // 2. Upload metadata JSON
  const metadata = {
    name: 'PUMP FUN API',
    symbol: 'PUMPDEV',
    description: 'The cheapest API for Pump.fun Token Creation & Trading - pumpdev.io',
    image: `ipfs://${image.IpfsHash}`,
    twitter: 'https://x.com/PumpDevIO',
    telegram: 'https://t.me/pumpdev_io',
    website: 'https://pumpdev.io/',
    showName: true,
  };

  const metaRes = await fetch('https://api.pinata.cloud/pinning/pinJSONToIPFS', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${PINATA_JWT}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ pinataContent: metadata }),
  });
  const pinned = await metaRes.json();
  if (!metaRes.ok) throw new Error(JSON.stringify(pinned));

  return `https://gateway.pinata.cloud/ipfs/${pinned.IpfsHash}`;
}

const metadataUri = await uploadMetadata();
console.log('Metadata URI:', metadataUri);

---

Step 2: Create a Token with Dev Buy — /api/create

Create a token on pump.fun with optional dev buy. Create + dev buy are combined into a single transaction — no Jito bundle needed!

Key Feature: Single Transaction Create + Buy

Unlike other APIs that require Jito bundles for create + buy, our API merges both into one transaction:

• ✅ No Jito required — works with any standard RPC
• ✅ Atomic — create and buy succeed or fail together
• ✅ Simpler — just sign one transaction and send it
• ✅ Optional Jito tip — add jitoTip for faster landing if you want

Request Parameters

Parameter	Type	Required	Description
publicKey	string	Yes	Creator wallet public key
name	string	Yes	Token name (max 32 chars)
symbol	string	Yes	Token symbol (max 10 chars)
uri	string	Yes	Metadata URI from Pinata or another IPFS/metadata host
buyAmountSol	number	No	Dev buy amount for native-SOL pairs
buyAmountQuote	number	No	Dev buy amount in quote-token units. Use this with quoteMint for USDC or other SPL quote pairs
quoteMint	string	No	Quote mint for the coin. Omit for native SOL/WSOL pairs
slippage	number	No	Slippage % for buy (default: 90)
jitoTip	number	No	Jito tip in SOL — only provide if sending via Jito (default: 0)
priorityFee	number	No	Priority fee in SOL (default: 0.0005)
mintKeypair	string	No	Base58 mint secret key — use when you need a specific token address (auto-generated if omitted)
mayhemMode	boolean	No	Enable Pump.fun Mayhem Mode on the token
cashbackEnabled	boolean	No	Enable cashback rewards for traders (default: not set)

Cashback Rewards

Setting cashbackEnabled: true creates a token where the creator fee is redirected back to traders as cashback instead of going to the token creator. Users can claim accumulated cashback via /api/claim-cashback. If omitted, the token behaves normally (creator receives fees).

Quote Mint Rules

• SOL pair: omit quoteMint and keep using buyAmountSol
• USDC pair: set quoteMint to the USDC mint and send buyAmountQuote
• The PumpDev API handles wrapped SOL under the hood, so SOL-paired coins are still funded and traded in native SOL from the caller's perspective

Response

Without jitoTip — single transaction (send via any RPC):

{
  "transaction": "base58-encoded-single-transaction",
  "mint": "TokenMintPublicKey",
  "mintSecretKey": "base58MintSecretKey"
}

With jitoTip — separate transactions (send as Jito bundle):

{
  "transactions": [
    { "transaction": "base58...", "signers": ["creator", "mint"], "description": "Create token" },
    { "transaction": "base58...", "signers": ["creator"], "description": "Dev buy" }
  ],
  "mint": "TokenMintPublicKey",
  "mintSecretKey": "base58MintSecretKey"
}

Two Modes

• No jitoTip → create + buy merged into ONE transaction. Sign with creator + mint keypair, send via any RPC. No Jito needed!
• With jitoTip → create and buy as SEPARATE transactions. Sign each and send as a Jito bundle.

Example: Create + Dev Buy in One Transaction

Create + dev buy in a single transaction. No Jito bundle required — just sign and send via any RPC!

import { VersionedTransaction, Connection, Keypair } from '@solana/web3.js';
import bs58 from 'bs58';

const API_URL = 'https://pumpdev.io';
const RPC_URL = 'https://api.mainnet-beta.solana.com';

async function createPumpfunToken(metadataUri) {
  const connection = new Connection(RPC_URL, 'confirmed');
  const creator = Keypair.fromSecretKey(bs58.decode('YOUR_PRIVATE_KEY'));

  // 1. Get single transaction from API (create + buy merged)
  const response = await fetch(`${API_URL}/api/create`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      publicKey: creator.publicKey.toBase58(),
      name: 'PUMP FUN API',
      symbol: 'PUMPDEV',
      uri: metadataUri,
      buyAmountSol: 0.5,      // Dev buy 0.5 SOL
      slippage: 90,
      // cashbackEnabled: true,  // Optional: enable cashback for traders
      // No jitoTip — not sending via Jito, just standard RPC
      // Only add jitoTip if you plan to send via Jito (see below)
    })
  });

  const result = await response.json();
  const mintKeypair = Keypair.fromSecretKey(bs58.decode(result.mintSecretKey));
  
  console.log('Mint:', result.mint);

  // 2. Sign the single transaction with creator + mint
  const tx = VersionedTransaction.deserialize(bs58.decode(result.transaction));
  tx.sign([creator, mintKeypair]);

  // 3. Send via standard RPC (no Jito bundle needed!)
  const signature = await connection.sendRawTransaction(tx.serialize(), {
    skipPreflight: true,
    maxRetries: 3
  });

  console.log('Signature:', signature);
  console.log(`Token: https://pump.fun/${result.mint}`);
}

Create a USDC-Quoted Coin

await fetch(`${API_URL}/api/create`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    publicKey: creator.publicKey.toBase58(),
    name: 'USDC Pair',
    symbol: 'USDCP',
    uri: metadataUri,
    quoteMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
    buyAmountQuote: 25,
    slippage: 90
  })
});

With Jito Tip (Only If Sending via Jito)

Add jitoTip to send via Jito for faster landing. With jitoTip, the API returns separate transactions (create + buy) that you send as a Jito bundle:

// Add jitoTip — API returns separate transactions for Jito bundle
const response = await fetch(`${API_URL}/api/create`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    publicKey: creator.publicKey.toBase58(),
    name: 'PUMP FUN API',
    symbol: 'PUMPDEV',
    uri: metadataUri,
    buyAmountSol: 0.5,
    slippage: 90,
    jitoTip: 0.01         // Only provide when sending via Jito
  })
});

const result = await response.json();
const mintKeypair = Keypair.fromSecretKey(bs58.decode(result.mintSecretKey));

// Sign each transaction: create tx needs creator+mint, buy tx needs creator only
const signedTxs = result.transactions.map((txInfo) => {
  const tx = VersionedTransaction.deserialize(bs58.decode(txInfo.transaction));
  const signers = txInfo.signers.includes('mint') ? [creator, mintKeypair] : [creator];
  tx.sign(signers);
  return bs58.encode(tx.serialize());
});

// Send as Jito bundle
await fetch('https://mainnet.block-engine.jito.wtf/api/v1/bundles', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0', id: 1, method: 'sendBundle',
    params: [signedTxs]
  })
});

---

Step 3: Multi-Buyer Launch with a Jito Bundle — /api/create-bundle

Create pump.fun token with multiple buyers in the same block using Jito bundles. Perfect for coordinated launches! See the full Jito Bundles Guide for advanced bundle strategies, trade bundles, and best practices.

Why Use a Pump.fun Bundle?

• ✅ Atomic Execution — All transactions succeed or fail together
• ✅ No Front-Running — Creator + buyers land in same block
• ✅ Up to 5 Transactions — Create + creator buy + 3 additional buyers
• ✅ Instant Volume — Multiple buys create immediate activity

Bundle Request Parameters

Parameter	Type	Required	Description
publicKey	string	Yes	Creator wallet public key
name	string	Yes	Token name
symbol	string	Yes	Token symbol
uri	string	Yes	Metadata URI
buyAmountSol	number	No	Creator's buy amount for native-SOL pairs
buyAmountQuote	number	No	Creator's buy amount in quote-token units for non-SOL pairs
quoteMint	string	No	Quote mint for the new coin. Omit for native SOL/WSOL pairs
slippage	number	No	Slippage % (default: 90)
jitoTip	number	No	Jito tip in SOL (default: 0.03). Bundles are Jito-specific, so keep a tip unless you intentionally want to override it. Below the market tip the bundle is dropped silently — see the launch-tip warning
priorityFee	number	No	Priority fee in SOL (default: 0.0005)
mintKeypair	string	No	Base58 mint secret key (auto-generated if omitted)
additionalBuyers	array	No	Up to 3 additional buyers
mayhemMode	boolean	No	Enable Pump.fun Mayhem Mode on the token
cashbackEnabled	boolean	No	Enable cashback rewards for traders

Provide one creator buy field: buyAmountSol for native-SOL pairs, or buyAmountQuote together with quoteMint for non-SOL quote pairs.

Additional Buyer Object

{ "publicKey": "BuyerWalletPublicKey", "amountSol": 0.5 }

For non-SOL quote pairs, use amountQuote instead:

{ "publicKey": "BuyerWalletPublicKey", "amountQuote": 25 }

Example: Creator + 3 Buyers in One Bundle

Launch your pump.fun token with multiple wallets buying atomically: create + creator buy + 3 additional buyers is 5 transactions, exactly filling a Jito bundle.

A launch needs a launch-sized tip

Your bundle bids against every other pump.fun launch in the same slot. Under the market tip Jito still returns a bundle id and then drops the bundle with no error at all. Measured on 2026-08-24: 0.02 SOL never landed, 0.03 SOL landed on the first slot every time. Confirm the mint exists on chain before treating a launch as successful.

async function createPumpfunBundle(metadataUri) {
  const creator = Keypair.fromSecretKey(bs58.decode('CREATOR_KEY'));
  const buyer1 = Keypair.fromSecretKey(bs58.decode('BUYER1_KEY'));
  const buyer2 = Keypair.fromSecretKey(bs58.decode('BUYER2_KEY'));
  const buyer3 = Keypair.fromSecretKey(bs58.decode('BUYER3_KEY'));
  
  const wallets = { creator, buyer1, buyer2, buyer3 };

  // 1. Request bundle from API
  const response = await fetch(`${API_URL}/api/create-bundle`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      publicKey: creator.publicKey.toBase58(),
      name: 'PUMP FUN API',
      symbol: 'PUMPDEV',
      uri: metadataUri,
      buyAmountSol: 1.0,        // Creator buys 1 SOL
      slippage: 90,
      jitoTip: 0.03,            // Launch tip — see the warning below
      additionalBuyers: [
        { publicKey: buyer1.publicKey.toBase58(), amountSol: 2.0 },
        { publicKey: buyer2.publicKey.toBase58(), amountSol: 1.5 },
        { publicKey: buyer3.publicKey.toBase58(), amountSol: 0.5 }
      ]
    })
  });

  const result = await response.json();
  const mintKeypair = Keypair.fromSecretKey(bs58.decode(result.mintSecretKey));

  console.log('Mint:', result.mint);
  console.log('Transactions:', result.transactions.length);

  // 2. Sign each transaction with appropriate signers
  const signedTxs = result.transactions.map((txInfo) => {
    const tx = VersionedTransaction.deserialize(bs58.decode(txInfo.transaction));
    const signers = txInfo.signers
      .map(s => s === 'mint' ? mintKeypair : wallets[s])
      .filter(Boolean);
    tx.sign(signers);
    return bs58.encode(tx.serialize());
  });

  // 3. Send as Jito bundle
  const bundleRes = await fetch(`${JITO_URL}/api/v1/bundles`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'sendBundle',
      params: [signedTxs]
    })
  });

  const bundleResult = await bundleRes.json();
  console.log('Bundle sent:', bundleResult.result);
  console.log(`Token: https://pump.fun/${result.mint}`);
}

Bundle Transaction Structure

A pump.fun bundle with creator + 2 additional buyers:

TX #	Description	Signers
1	Create token	creator, mint
2	Creator buy	creator
3	Buyer 1 buy	buyer1
4	Buyer 2 buy	buyer2

All transactions execute atomically in the same Solana block.

Jito Bundle Endpoints

Send your pump.fun bundles to any Jito block engine:

const JITO_ENDPOINTS = [
  'https://mainnet.block-engine.jito.wtf',
  'https://amsterdam.mainnet.block-engine.jito.wtf',
  'https://frankfurt.mainnet.block-engine.jito.wtf',
  'https://ny.mainnet.block-engine.jito.wtf',
  'https://tokyo.mainnet.block-engine.jito.wtf'
];

Tip: Send to multiple endpoints for better landing rates!

---

Error Responses

All endpoints return JSON errors with an error field:

{ "error": "Description of what went wrong" }

HTTP Status	Cause
400	Missing required fields, invalid parameters, or malformed request
402	Insufficient SOL balance for transaction + fees
500	Transaction build failed (invalid metadata URI, network issues)

For Jito bundles, check the Jito bundle ID status if the bundle was accepted but transactions don't appear on-chain — the bundle may have landed in a failed slot.

---

Best Practices for Pump.fun Token Launch

1. Use /api/create for single-wallet launches — Create + dev buy in one transaction, no Jito needed
2. Use /api/create-bundle for multi-wallet launches — Jito bundle for atomic multi-buyer execution
3. Only provide jitoTip to /api/create if sending via Jito — it defaults to 0 there and adds a tip instruction only when set. Don't set it when sending via standard RPC. /api/create-bundle is Jito-only and defaults to 0.03 — keep a launch-sized tip
4. Use server defaults first — Override slippage only when your strategy needs it
5. Fund all wallets first — Ensure all buyers have enough SOL
6. Test on devnet — Validate your flow before mainnet

---

Next Steps

• Jito Bundles Guide — Advanced Jito bundle strategies, trade bundles, and best practices
• Lightning Create — One-call token launch (no signing required)
• Lightning Trade — One-call buy/sell
• Trade API — Client-side buy and sell tokens
• WebSocket Data — Real-time pump.fun trades
• Claim Fees — Collect creator royalties
• PONS Create Token — Launching on Robinhood Chain instead? The same one-POST launch on ponsfamily.com's curve