Skip to main content

Pump.fun Token Creation

You can create tokens via the pump.fun API.

There is no additional fee for token creation. The standard trading fee is applied to the initial dev buy.

Pump.fun no longer allows direct metadata uploads to their API.

The old pump.fun/api/ipfs endpoint is no longer supported. To create coins programatically, you must now upload metadata to an IPFS service. We have updated our examples to use Pinata IPFS. To use our token creation examples, create a free Pinata account and API key, copy the JWT key, and paste it into the examples below:

Lightning Transaction Examples:​

async function sendCreateTx() {
    // Generate a random keypair for token
    const mintKeypair = Keypair.generate();
    const pinataJWT = "************"  
    // Token information
    const name = "PPTest";
    const symbol = "TEST";
    const description = "This is a test token created by PumpPortal.fun";
    const twitter = "https://x.com/a1lon9/status/1812970586420994083";
    const telegram = "https://x.com/a1lon9/status/1812970586420994083";
    const website = "https://pumpportal.fun";

    // Upload token image to IPFS
    const formDataImage = new FormData();
    formDataImage.append("network", "public")
    formDataImage.append("file", await fs.openAsBlob("./example.png")); // Image file

    const options = {
        method: 'POST',
        headers: {Authorization: `Bearer ${pinataJWT}`},
        body: formDataImage
    };


    let imageUploadResult = await fetch('https://uploads.pinata.cloud/v3/files', options)
    let imageResultJson = await imageUploadResult.json();
    let image = `https://ipfs.io/ipfs/${imageResultJson.data.cid}`;

    // Create IPFS metadata storage

    let metadataFile = new File([JSON.stringify({name, symbol, image, description, twitter, telegram, website})], "file");
    const formDataMetaData = new FormData();
    formDataMetaData.append("network", "public");
    formDataMetaData.append("file", metadataFile); // Image file
        
    options.body = formDataMetaData;

    let metadataResponse = await fetch('https://uploads.pinata.cloud/v3/files', options)
    const metadataResponseJSON = await metadataResponse.json();

    // Get the create transaction
    const response = await fetch(
        `https://pumpportal.fun/api/trade?api-key=${pumpPortalAPIKey}`,
        {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
        },
        body: JSON.stringify({
            action: "create",
            tokenMetadata: {
            name: name,
            symbol: symbol,
            uri: `https://ipfs.io/ipfs/${metadataResponseJSON.data.cid}`,
            },
            mint: bs58.encode(mintKeypair.secretKey), // contract address of the token you want to trade
            denominatedInSol: "true", // "true" if amount is amount of SOL, "false" if amount is number of tokens
            amount: 0.01, // amount of SOL or tokens
            slippage: 15, // percent slippage allowed
            priorityFee: 0.00005,
            pool: "pump"
        }),
        }
    );
    if (response.status === 200) {
        // successfully generated transaction
        const data = await response.json();
        console.log("Transaction: https://solscan.io/tx/" + data.signature);
    } else {
        console.log(response.statusText); // log error
    }
}

sendCreateTx()

Local Transaction Examples:​

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

const RPC_ENDPOINT = "Your RPC Endpoint";
const web3Connection = new Connection(
    RPC_ENDPOINT,
    'confirmed',
);

async function sendLocalCreateTx() {
    const signerKeyPair = Keypair.fromSecretKey(
        bs58.decode(
        "**********"
        )
    );

    // Generate a random keypair for token
    const mintKeypair = Keypair.generate();
    const pinataJWT = "***************";
    
    // Token information
    const name = "PPTest";
    const symbol = "TEST";
    const description = "This is a test token created by PumpPortal.fun";
    const twitter = "https://x.com/a1lon9/status/1812970586420994083";
    const telegram = "https://x.com/a1lon9/status/1812970586420994083";
    const website = "https://pumpportal.fun";

    // Upload token image to IPFS
    const formDataImage = new FormData();
    formDataImage.append("network", "public")
    formDataImage.append("file", await fs.openAsBlob("./example.png")); // Image file

    const options = {
        method: 'POST',
        headers: {Authorization: `Bearer ${pinataJWT}`},
        body: formDataImage
    };


    let imageUploadResult = await fetch('https://uploads.pinata.cloud/v3/files', options)
    let imageResultJson = await imageUploadResult.json();
    let image = `https://ipfs.io/ipfs/${imageResultJson.data.cid}`;

    // Create IPFS metadata storage

    let metadataFile = new File([JSON.stringify({name, symbol, image, description, twitter, telegram, website})], "file");
    const formDataMetaData = new FormData();
    formDataMetaData.append("network", "public");
    formDataMetaData.append("file", metadataFile); // Image file
        
    options.body = formDataMetaData;

    let metadataResponse = await fetch('https://uploads.pinata.cloud/v3/files', options)
    const metadataResponseJSON = await metadataResponse.json();

    // Get the create transaction
    const response = await fetch(`https://pumpportal.fun/api/trade-local`, {
        method: "POST",
        headers: {
        "Content-Type": "application/json",
        },
        body: JSON.stringify({
        publicKey: signerKeyPair.publicKey.toBase58(),
        action: "create",
        tokenMetadata: {
            name: name,
            symbol: symbol,
            uri: `https://ipfs.io/ipfs/${metadataResponseJSON.data.cid}`,
        },
        mint: mintKeypair.publicKey.toBase58(),
        denominatedInSol: "true",
        amount: 0.0001, // dev buy of 1 SOL
        slippage: 10,
        priorityFee: 0.00001,
        pool: "pump",
        }),
    });
    if (response.status === 200) {
        // successfully generated transaction
        const data = await response.arrayBuffer();
        const tx = VersionedTransaction.deserialize(new Uint8Array(data));
        tx.sign([mintKeypair, signerKeyPair]);
        const signature = await web3Connection.sendTransaction(tx);
        console.log("Transaction: https://solscan.io/tx/" + signature);
    } else {
        console.log(response.statusText); // log error
    }
}

sendLocalCreateTx();

Jito Bundle Examples:​

import requests
import base58
from solders.transaction import VersionedTransaction
from solders.keypair import Keypair

def send_create_tx_bundle():
    signerKeypairs = [
        Keypair.from_base58_string("Wallet A base 58 private key here"),
        Keypair.from_base58_string("Wallet B base 58 private key here")
        # use up to 5 wallets
    ]

    # Generate a random keypair for token
    mint_keypair = Keypair()

    # Define token metadata
    form_data = {
        'name': 'PPTest',
        'symbol': 'TEST',
        'description': 'This is an example token created via PumpPortal.fun',
        'twitter': 'https://x.com/a1lon9/status/1812970586420994083',
        'telegram': 'https://x.com/a1lon9/status/1812970586420994083',
        'website': 'https://pumpportal.fun',
        'showName': 'true'
    }

    # Read the image file
    with open('./example.png', 'rb') as f:
        file_content = f.read()

    files = {
        'file': ('example.png', file_content, 'image/png')
    }

    # Create IPFS metadata storage
    metadata_response = requests.post("https://pump.fun/api/ipfs", data=form_data, files=files)
    metadata_response_json = metadata_response.json()

    # Token metadata
    token_metadata = {
        'name': form_data['name'],
        'symbol': form_data['symbol'],
        'uri': metadata_response_json['metadataUri']
    }

    bundledTransactionArgs = [
        {
            'publicKey': str(signerKeypairs[0].pubkey()),
            'action': 'create',
            'tokenMetadata': token_metadata,
            'mint': str(mint_keypair.pubkey()),
            'denominatedInSol': 'false',
            'amount': 1000000, # Dev buy of 1000000 tokens
            'slippage': 10,
            'priorityFee': 0.0005,
            'pool': 'pump'
        },
        {
            "publicKey": str(signerKeypairs[1].pubkey()),
            "action": "buy",  # "buy", "sell", or "create"
            "mint": str(mint_keypair.pubkey()), 
            "denominatedInSol": "false",
            "amount": 1000000,
            "slippage": 50,
            "priorityFee": 0.0001, # priority fee after first tx is ignored
            "pool": "pump"
        }
        # use up to 5 transactions
    ]

    # Generate the bundled transactions
    response = requests.post(
        "https://pumpportal.fun/api/trade-local",
        headers={"Content-Type": "application/json"},
        json=bundledTransactionArgs
    )

    if response.status_code != 200: 
        print("Failed to generate transactions.")
        print(response.reason)
    else:
        encodedTransactions = response.json()
        encodedSignedTransactions = []
        txSignatures = []

        for index, encodedTransaction in enumerate(encodedTransactions):
            if bundledTransactionArgs[index]["action"] == "create":
                signedTx = VersionedTransaction(VersionedTransaction.from_bytes(base58.b58decode(encodedTransaction)).message, [mint_keypair, signerKeypairs[index]])
            else:
                signedTx = VersionedTransaction(VersionedTransaction.from_bytes(base58.b58decode(encodedTransaction)).message, [signerKeypairs[index]])
            
            encodedSignedTransactions.append(base58.b58encode(bytes(signedTx)).decode())
            txSignatures.append(str(signedTx.signatures[0]))

        jito_response = requests.post(
            "https://mainnet.block-engine.jito.wtf/api/v1/bundles",
            headers={"Content-Type": "application/json"},
            json={
                "jsonrpc": "2.0",
                "id": 1,
                "method": "sendBundle",
                "params": [
                    encodedSignedTransactions
                ]
            }
        )

        for i, signature in enumerate(txSignatures):
            print(f'Transaction {i}: https://solscan.io/tx/{signature}')

send_create_tx_bundle()

Bonk Token Creation Examples:​

Create Bonk tokens using the Lightning API:

import requests
import json
from solders.keypair import Keypair

def send_create_tx_bonk():
    # Generate a random keypair for token
    mint_keypair = Keypair()
    print("Token CA generated. Token address: ")
    print(mint_keypair.pubkey())

    name = "PumpPortalTest"
    symbol = "PORTAL"

    # Read the image file
    with open('./example.png', 'rb') as f:
        file_content = f.read()

    files = {
        'image': ('example.png', file_content, 'image/png')
    }

    # Create IPFS metadata storage
    img_response = requests.post("https://nft-storage.letsbonk22.workers.dev/upload/img", files=files)
    img_uri = img_response.text

    metadata_response = requests.post(
        "https://nft-storage.letsbonk22.workers.dev/upload/meta",
        headers={'Content-Type': 'application/json'},
        data=json.dumps({
            'createdOn': "https://bonk.fun",
            'description': "Test token for PumpPortal.fun",
            'image': img_uri,
            'name': name,
            'symbol': symbol,
            'website': "https://pumpportal.fun"
        })
    )
    metadata_uri = metadata_response.text

    # Token metadata
    token_metadata = {
        'name': name,
        'symbol': symbol,
        'uri': metadata_uri
    }

    # Send the create transaction
    response = requests.post(
        "https://pumpportal.fun/api/trade?api-key=your-api-key-here",
        headers={'Content-Type': 'application/json'},
        data=json.dumps({
            'action': 'create',
            'tokenMetadata': token_metadata,
            'mint': str(mint_keypair),
            'denominatedInSol': 'true',
            'amount': 1, # Dev buy of 1 SOL
            'slippage': 10,
            'priorityFee': 0.00005,
            'pool': 'bonk',
            'quoteMint': "USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB" # default 'So11111111111111111111111111111111111111112'
        })
    )

    if response.status_code == 200:  # successfully generated transaction
        data = response.json()
        print(f"Transaction: https://solscan.io/tx/{data['signature']}")
    else:
        print(response.reason)  # log error

send_create_tx_bonk()