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.

Examples below:

Lightning Transaction Examples:

Python

import requests
import json
from solders.keypair import Keypair

def send_create_tx():
    # 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']
    }

    # Send the create transaction
    response = requests.post(
        "https://pumpportal.fun/api/trade?api-key=your-api-key",
        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.0005,
            'pool': 'pump'
        })
    )

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

JavaScript

async function sendCreateTx(){

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

    // Send the create transaction
    const response = await fetch(`https://pumpportal.fun/api/trade?api-key=your-api-key`, {
        method: "POST",
        headers: {
            "Content-Type": "application/json"
        },
        body: JSON.stringify({
            "action": "create",
            "tokenMetadata": {
                name: metadataResponseJSON.metadata.name,
                symbol: metadataResponseJSON.metadata.symbol,
                uri: metadataResponseJSON.metadataUri
            },
            "mint": bs58.encode(mintKeypair.secretKey), 
            "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.json();
        console.log("Transaction: https://solscan.io/tx/" + data.signature);
    } else {
        console.log(response.statusText); // log error
    }
}

sendCreateTx();

Local Transaction 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();

Bonk Token Creation Examples:

Python

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 = {
        'file': ('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'
        })
    )

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

JavaScript

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

    const name = "PumpPortalTest";
    const symbol = "PORTAL";
    
    const formData = new FormData();
    formData.append("image", await fs.openAsBlob("./example.png")) // Image file

    // Create IPFS metadata storage
    const imgResponse = await fetch("https://nft-storage.letsbonk22.workers.dev/upload/img", {
        method: "POST",
        body: formData,
    });
    let imgUri = await imgResponse.text()
    console.log(imgUri);
    const metadataResponse = await fetch("https://nft-storage.letsbonk22.workers.dev/upload/meta", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
        },
        body: JSON.stringify({
            createdOn: "https://bonk.fun",
            description: "Test token for PumpPortal.fun",
            image: imgUri,
            name: name,
            symbol: symbol,
            website: "https://pumpportal.fun"
        }),
    })
    let metadataUri = await metadataResponse.text();
    console.log(metadataUri);

    // 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: metadataUri,
            },
            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.5, // amount of SOL or tokens
            slippage: 5, // percent slippage allowed
            priorityFee: 0.00005,
            pool: "bonk"
        }),
        }
    );
    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
    }
}

sendCreateTxBonk();