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 of 0.5% is applied to the initial dev buy.

Examples below:

Examples:

Python

import requests
import json
from solders.keypair import Keypair
from solders.transaction import VersionedTransaction
from solders.keypair import Keypair
from solders.commitment_config import CommitmentLevel
from solders.rpc.requests import SendVersionedTransaction
from solders.rpc.config import RpcSendTransactionConfig

def send_local_create_tx():
    signer_keypair = Keypair.from_base58_string('your-base58-private-key')

    # 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']
    }

    # Generate the create transaction
    response = requests.post(
        "https://pumpportal.fun/api/trade-local",
        headers={'Content-Type': 'application/json'},
        data=json.dumps({
            'publicKey': str(signer_keypair.pubkey()),
            'action': 'create',
            'tokenMetadata': token_metadata,
            'mint': str(mint_keypair.pubkey()),
            'denominatedInSol': 'true',
            'amount': 1, # Dev buy of 1 SOL
            'slippage': 10,
            'priorityFee': 0.0005,
            'pool': 'pump'
        })
    )

    tx = VersionedTransaction(VersionedTransaction.from_bytes(response.content).message, [mint_keypair, signer_keypair])

    commitment = CommitmentLevel.Confirmed
    config = RpcSendTransactionConfig(preflight_commitment=commitment)
    txPayload = SendVersionedTransaction(tx, config)

    response = requests.post(
        url="Your RPC endpoint - Eg: https://api.mainnet-beta.solana.com/",
        headers={"Content-Type": "application/json"},
        data=SendVersionedTransaction(tx, config).to_json()
    )
    txSignature = response.json()['result']
    print(f'Transaction: https://solscan.io/tx/{txSignature}')

send_local_create_tx()

JavaScript

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("your-wallet-private-key"));

    // Generate a random keypair for token
    const mintKeypair = Keypair.generate(); 

    // Define token metadata
    const formData = new FormData();
    formData.append("file", await fs.openAsBlob("./example.png")), // Image file
    formData.append("name", "PPTest"),
    formData.append("symbol", "TEST"),
    formData.append("description", "This is an example token created via PumpPortal.fun"),
    formData.append("twitter", "https://x.com/a1lon9/status/1812970586420994083"),
    formData.append("telegram", "https://x.com/a1lon9/status/1812970586420994083"),
    formData.append("website", "https://pumpportal.fun"),
    formData.append("showName", "true");

    // Create IPFS metadata storage
    const metadataResponse = await fetch("https://pump.fun/api/ipfs", {
        method: "POST",
        body: formData,
    });
    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": 'your-wallet-public-key',
            "action": "create",
            "tokenMetadata": {
                name: metadataResponseJSON.metadata.name,
                symbol: metadataResponseJSON.metadata.symbol,
                uri: metadataResponseJSON.metadataUri
            },
            "mint": mintKeypair.publicKey.toBase58(),
            "denominatedInSol": "true",
            "amount": 1, // dev buy of 1 SOL
            "slippage": 10, 
            "priorityFee": 0.0005,
            "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:

Python

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()

JavaScript

async function sendLocalCreateBundle(){
    const signerKeyPairs = [
        Keypair.fromSecretKey(bs58.decode("Wallet A base 58 private key here")),
        Keypair.fromSecretKey(bs58.decode("Wallet B base 58 private key here")),
        // use up to 5 wallets
    ];
    const mintKeypair = Keypair.generate(); // generates a random keypair for token
    let tokenMetadata = {
        name: "TEST",
        symbol: "AAA",
        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",
        file: await fs.openAsBlob("./new-moon-face.png"),
    };
    let formData = new FormData();
    formData.append("file", tokenMetadata.file),
    formData.append("name", tokenMetadata.name),
    formData.append("symbol", tokenMetadata.symbol),
    formData.append("description", tokenMetadata.description),
    formData.append("twitter", tokenMetadata.twitter || ""),
    formData.append("telegram", tokenMetadata.telegram || ""),
    formData.append("website", tokenMetadata.website || ""),
    formData.append("showName", "true");
    let metadataResponse = await fetch("https://pump.fun/api/ipfs", {
    method: "POST",
    body: formData,
    });
    let metadataResponseJSON = await metadataResponse.json();
    const bundledTxArgs = [
        {
            "publicKey": signerKeyPairs[0].publicKey.toBase58(),
            "action": "create",
            "tokenMetadata": {name: tokenMetadata.name, symbol: tokenMetadata.symbol, uri: metadataResponseJSON.metadataUri},
            "mint": mintKeypair.publicKey.toBase58(),
            "denominatedInSol": "false",
            "amount": 10000000,
            "slippage": 10, 
            "priorityFee": 0.0001, // priority fee on the first tx is used for jito tip
            "pool": "pump"
        },
        {
            publicKey: signerKeyPairs[1].publicKey.toBase58(),
            "action": "buy", 
            "mint": mintKeypair.publicKey.toBase58(), 
            "denominatedInSol": "false",  
            "amount": 10000000, 
            "slippage": 10, 
            "priorityFee": 0.00005, // priority fee after first tx is ignored
            "pool": "pump"
        },
        // use up to 5 transactions
        
    ];
    const response = await fetch(`https://pumpportal.fun/api/trade-local`, {
        method: "POST",
        headers: {
            "Content-Type": "application/json"
        },
        body: JSON.stringify(bundledTxArgs)
    });
    if(response.status === 200){ // successfully generated transactions
        const transactions = await response.json();
        let encodedSignedTransactions = [];
        let signatures = [];
        for(let i = 0; i < bundledTxArgs.length; i++){
            const tx = VersionedTransaction.deserialize(new Uint8Array(bs58.decode(transactions[i])));
            if(bundledTxArgs[i].action === "create"){  // creation transaction needs to be signed by mint and creator keypairs
                tx.sign([mintKeypair, signerKeyPairs[i]])
            } else {
                tx.sign([signerKeyPairs[i]]);
            }
            encodedSignedTransactions.push(bs58.encode(tx.serialize()));
            signatures.push(bs58.encode(tx.signatures[0]));
        }
        
        try{
            const jitoResponse = 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": [
                    encodedSignedTransactions
                    ]
                })
            });
            console.log(jitoResponse);
        } catch(e){
            console.error(e.message);
        }
        for(let i = 0; i < signatures.length; i++){
            console.log(`Transaction ${i}: https://solscan.io/tx/${signatures[i]}`);
        }
    } else {
        console.log(response.statusText); // log error
    }
}

sendLocalCreateBundle();