PumpPortal

https://pumpportal.fun
Admin
PumpPortal provides a 3rd-Party API for Raydium and Pump.fun, offering low-latency data sources and...
Tokens:14,583
Snippets:59
Trust Score:6.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Create Wallet via API

Source: https://pumpportal.fun/create-wallet

Sends a GET request to the create-wallet endpoint to generate a new wallet and API key.

```python
import requests  
   
response = requests.get(url="https://pumpportal.fun/api/create-wallet")  
   
# JSON with keys for a newly generated wallet and the linked API key  
data = response.json()  
```

```javascript
const response = await fetch("https://pumpportal.fun/api/create-wallet", {  
  method: "GET",  
});  
  
// JSON Object with keys for a newly generated wallet and the linked API key  
const data = await response.json();   
```

```curl
curl -L \
-X GET \
'https://pumpportal.fun/api/create-wallet'  
```

--------------------------------

### GET https://pumpportal.fun/api/create-wallet

Source: https://pumpportal.fun/create-wallet

Creates a new Lightning wallet and a linked API key.

```APIDOC
## GET https://pumpportal.fun/api/create-wallet

### Description
Creates a new Lightning wallet and a linked API key.

### Method
GET

### Endpoint
https://pumpportal.fun/api/create-wallet

### Response
#### Success Response (200)
- **JSON Object** - Contains keys for the newly generated wallet and the linked API key.
```

--------------------------------

### Send Local Create Bundle

Source: https://pumpportal.fun/creation

Demonstrates how to upload metadata to IPFS, generate bundled transaction arguments, sign them locally, and submit the bundle to the Jito block engine.

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

--------------------------------

### Create Bonk Token with Python

Source: https://pumpportal.fun/creation

Uses the requests library to upload metadata to IPFS and send a token creation transaction to the PumpPortal API.

```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 = {  
        '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()
```

--------------------------------

### Create Token with Local Transaction in JavaScript

Source: https://pumpportal.fun/creation

Uses @solana/web3.js to generate a token, upload metadata to IPFS via Pinata, and sign a transaction locally.

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

--------------------------------

### Create Bonk Token with JavaScript

Source: https://pumpportal.fun/creation

Uses the Fetch API to upload metadata to IPFS and submit a token creation transaction to the PumpPortal API.

```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",  
            quoteMint: "USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB" // default 'So11111111111111111111111111111111111111112'  
        }),  
        }  
    );  
    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();
```

--------------------------------

### Construct and Send Jito Bundles in Python

Source: https://pumpportal.fun/local-trading-api/jito-bundles

Sends an array of trade requests to the API, signs the returned transactions, and submits them as a Jito bundle.

```python
import requests  
import base58  
from solders.transaction import VersionedTransaction  
from solders.keypair import Keypair  
  
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  
]  
  
response = requests.post(  
    "https://pumpportal.fun/api/trade-local",  
    headers={"Content-Type": "application/json"},  
    json=[  
        {  
            "publicKey": str(signerKeypairs[0].pubkey()),  
            "action": "buy",  # "buy", "sell", or "create"  
            "mint": "2xHkesAQteG9yz48SDaVAtKdFU6Bvdo9sXS3uQCbpump",   
            "denominatedInSol": "false",  
            "amount": 1000,  
            "slippage": 50,  
            "priorityFee": 0.0001, # priority fee on the first tx is used for jito tip  
            "pool": "pump"  
        },  
        {  
            "publicKey": str(signerKeypairs[1].pubkey()),  
            "action": "buy",  # "buy", "sell", or "create"  
            "mint": "2xHkesAQteG9yz48SDaVAtKdFU6Bvdo9sXS3uQCbpump",   
            "denominatedInSol": "false",  
            "amount": 1000,  
            "slippage": 50,  
            "priorityFee": 0.0001, # priority fee after first tx is ignored  
            "pool": "pump"  
        }  
        # use up to 5 transactions  
    ]  
)  
  
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):  
        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 Jito Transaction Bundle

Source: https://pumpportal.fun/local-trading-api/jito-bundles

Demonstrates how to fetch unsigned transactions from PumpPortal, sign them with multiple keypairs, and submit them as a Jito bundle.

```typescript
import { VersionedTransaction, Connection, Keypair, sendAndConfirmTransaction} from '@solana/web3.js';  
import bs58 from "bs58";  
  
async function sendTransactionBundle(){  
    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 bundledTxArgs = [  
        {  
            publicKey: signerKeyPairs[0].publicKey.toBase58(),  
            "action": "buy", // "buy", "sell", or "create"  
            "mint": "2xHkesAQteG9yz48SDaVAtKdFU6Bvdo9sXS3uQCbpump",   
            "denominatedInSol": "false",    
            "amount": 1000000,   
            "slippage": 50,   
            "priorityFee": 0.00005, //priority fee on the first tx is used for jito tip  
            "pool": "pump"  
        },  
        {  
            publicKey: signerKeyPairs[1].publicKey.toBase58(),  
            "action": "buy", // "buy", "sell", or "create"  
            "mint": "2xHkesAQteG9yz48SDaVAtKdFU6Bvdo9sXS3uQCbpump",   
            "denominatedInSol": "false",    
            "amount": 1000000,   
            "slippage": 50,   
            "priorityFee": 0.0, //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 transaction  
        const transactions = await response.json();  
        console.log(transactions);  
        let encodedSignedTransactions = [];  
        let signatures = [];  
        for(let i = 0; i < bundledTxArgs.length; i++){ //decode and sign each tx  
            const tx = VersionedTransaction.deserialize(new Uint8Array(bs58.decode(transactions[i])));  
            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  
    }  
}  
sendTransactionBundle();
```

--------------------------------

### Execute Trade with Python

Source: https://pumpportal.fun/local-trading-api/trading-api

Uses the requests library to fetch a serialized transaction and signs it using the solders library.

```python
import requests  
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  
  
response = requests.post(url="https://pumpportal.fun/api/trade-local", data={  
    "publicKey": "Your public key here",  
    "action": "buy",             # "buy" or "sell"  
    "mint": "token CA here",     # contract address of the token you want to trade  
    "amount": 100000,            # amount of SOL or tokens to trade  
    "denominatedInSol": "false", # "true" if amount is amount of SOL, "false" if amount is number of tokens  
    "slippage": 10,              # percent slippage allowed  
    "priorityFee": 0.005,        # amount to use as priority fee  
    "pool": "auto"               # exchange to trade on. "pump", "raydium", "pump-amm", 'launchlab', 'raydium-cpmm', 'bonk', or "auto"  
})  
  
keypair = Keypair.from_base58_string("Your base 58 private key here")  
tx = VersionedTransaction(VersionedTransaction.from_bytes(response.content).message, [keypair])  
  
commitment = CommitmentLevel.Confirmed  
config = RpcSendTransactionConfig(preflight_commitment=commitment)  
txPayload = SendVersionedTransaction(tx, config)  
  
response = requests.post(  
    url="Your RPC Endpoint here - 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}')
```

--------------------------------

### Execute Trade with JavaScript

Source: https://pumpportal.fun/local-trading-api/trading-api

Uses the fetch API to retrieve a transaction and signs it using the @solana/web3.js library.

```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 sendPortalTransaction(){  
  const response = await fetch(`https://pumpportal.fun/api/trade-local`, {  
      method: "POST",  
      headers: {  
          "Content-Type": "application/json"  
      },  
      body: JSON.stringify({  
          "publicKey": "your-public-key",  // Your wallet public key  
          "action": "buy",                 // "buy" or "sell"  
          "mint": "token-ca-here",         // contract address of the token you want to trade  
          "denominatedInSol": "false",     // "true" if amount is amount of SOL, "false" if amount is number of tokens  
          "amount": 1000,                  // amount of SOL or tokens  
          "slippage": 10,                  // percent slippage allowed  
          "priorityFee": 0.00001,          // priority fee  
          "pool": "auto"                   // exchange to trade on. "pump", "raydium", "pump-amm", 'launchlab', 'raydium-cpmm', 'bonk' or "auto"  
      })  
  });  
  if(response.status === 200){ // successfully generated transaction  
      const data = await response.arrayBuffer();  
      const tx = VersionedTransaction.deserialize(new Uint8Array(data));  
      const signerKeyPair = Keypair.fromSecretKey(bs58.decode("your-wallet-private-key"));  
      tx.sign([signerKeyPair]);  
      const signature = await web3Connection.sendTransaction(tx)  
      console.log("Transaction: https://solscan.io/tx/" + signature);  
  } else {  
      console.log(response.statusText); // log error  
  }  
}  
  
sendPortalTransaction();
```

--------------------------------

### Execute Trade with cURL

Source: https://pumpportal.fun/trading-api

Sends a POST request using the command line. Ensure the JSON body is correctly formatted and passed via the -d flag.

```bash
curl -L \
-X POST \
-H 'Content-Type: application/json' \
'https://pumpportal.fun/api/trade?api-key=your-api-key-here' \
-d '  
{  
"action": "buy",  
"mint": "your CA here",  
"amount": 0.01,  
"denominatedInSol": "true",  
"slippage": 10,  
"priorityFee": 0.00005,  
"pool": "pump"  
}  
'  
```

--------------------------------

### Execute Trade with Python

Source: https://pumpportal.fun/trading-api

Uses the requests library to send a POST request to the trade endpoint. Ensure the API key is correctly appended to the URL query parameters.

```python
import requests  
   
response = requests.post(url="https://pumpportal.fun/api/trade?api-key=your-api-key-here", data={  
    "action": "buy",             # "buy" or "sell"  
    "mint": "your CA here",      # contract address of the token you want to trade  
    "amount": 100000,            # amount of SOL or tokens to trade  
    "denominatedInSol": "false", # "true" if amount is amount of SOL, "false" if amount is number of tokens  
    "slippage": 10,              # percent slippage allowed  
    "priorityFee": 0.00005,        # amount used to enhance transaction speed  
    "pool": "auto"               # exchange to trade on. "pump", "raydium", "pump-amm", "launchlab", "raydium-cpmm", "bonk" or "auto"  
})  
   
data = response.json()           # Tx signature or error(s)  
  
```

--------------------------------

### Create and Bundle Transactions with Jito

Source: https://pumpportal.fun/creation

Uses the PumpPortal API to generate transaction bytes for token creation and trading, then signs and submits them as a Jito bundle.

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

--------------------------------

### POST /api/trade

Source: https://pumpportal.fun/creation

Submits a request to create a new token on the Bonk pool. Requires an API key and token metadata.

```APIDOC
## POST /api/trade

### Description
Creates a new token on the Bonk pool. This endpoint requires the token metadata (name, symbol, and URI) and transaction parameters.

### Method
POST

### Endpoint
https://pumpportal.fun/api/trade?api-key={api-key}

### Request Body
- **action** (string) - Required - Must be set to 'create'.
- **tokenMetadata** (object) - Required - Contains name, symbol, and uri.
- **mint** (string) - Required - The mint keypair/address.
- **denominatedInSol** (string) - Required - 'true' if amount is in SOL, 'false' if in tokens.
- **amount** (number) - Required - Amount of SOL or tokens for the initial buy.
- **slippage** (number) - Required - Allowed slippage percentage.
- **priorityFee** (number) - Required - Priority fee for the transaction.
- **pool** (string) - Required - Set to 'bonk'.
- **quoteMint** (string) - Required - The quote mint address.

### Response
#### Success Response (200)
- **signature** (string) - The transaction signature.
```

--------------------------------

### Subscribe to Data Streams

Source: https://pumpportal.fun/data-api/bonk-fun-data-api

Connect to the WebSocket server and send JSON payloads to subscribe to token creations, migrations, and specific account or token trades.

```python
import asyncio  
import websockets  
import json  
  
async def subscribe():  
  uri = "wss://pumpportal.fun/api/data?api-key=your-api-key-here"  
  async with websockets.connect(uri) as websocket:  
        
      # Subscribing to token creation events  
      payload = {  
          "method": "subscribeNewToken",  
      }  
      await websocket.send(json.dumps(payload))  
  
      # Subscribing to migration events  
      payload = {  
          "method": "subscribeMigration",  
      }  
      await websocket.send(json.dumps(payload))  
  
      # Subscribing to trades made by accounts  
      payload = {  
          "method": "subscribeAccountTrade",  
          "keys": ["AArPXm8JatJiuyEffuC1un2Sc835SULa4uQqDcaGpAjV"]  # array of accounts to watch  
      }  
      await websocket.send(json.dumps(payload))  
  
      # Subscribing to trades on tokens  
      payload = {  
          "method": "subscribeTokenTrade",  
          "keys": ["91WNez8D22NwBssQbkzjy4s2ipFrzpmn5hfvWVe2aY5p"]  # array of token CAs to watch  
      }  
      await websocket.send(json.dumps(payload))  
        
      async for message in websocket:  
          print(json.loads(message))  
  
# Run the subscribe function  
asyncio.get_event_loop().run_until_complete(subscribe())
```

```javascript
import WebSocket from 'ws';  
  
const ws = new WebSocket('wss://pumpportal.fun/api/data?api-key=your-api-key-here');  
  
ws.on('open', function open() {  
  
  // Subscribing to token creation events  
  let payload = {  
      method: "subscribeNewToken",   
    }  
  ws.send(JSON.stringify(payload));  
  
  // Subscribing to migration events  
  let payload = {  
      method: "subscribeMigration",   
    }  
  ws.send(JSON.stringify(payload));  
  
  // Subscribing to trades made by accounts  
  payload = {  
      method: "subscribeAccountTrade",  
      keys: ["AArPXm8JatJiuyEffuC1un2Sc835SULa4uQqDcaGpAjV"] // array of accounts to watch  
    }  
  ws.send(JSON.stringify(payload));  
  
  // Subscribing to trades on tokens  
  payload = {  
      method: "subscribeTokenTrade",  
      keys: ["91WNez8D22NwBssQbkzjy4s2ipFrzpmn5hfvWVe2aY5p"] // array of token CAs to watch  
    }  
  ws.send(JSON.stringify(payload));  
});  
  
ws.on('message', function message(data) {  
  console.log(JSON.parse(data));  
});
```

--------------------------------

### POST /api/trade-local

Source: https://pumpportal.fun/local-trading-api/jito-bundles

Constructs a set of transactions for a Jito bundle by sending an array of trade objects to the PumpPortal API.

```APIDOC
## POST /api/trade-local

### Description
Constructs multiple transactions to be included in a Jito bundle. The request body must be an array of trade objects.

### Method
POST

### Endpoint
https://pumpportal.fun/api/trade-local

### Request Body
- **Array of objects** (array) - Required - A list of trade objects (up to 5) containing:
    - **publicKey** (string) - Required - The public key of the signer.
    - **action** (string) - Required - The action to perform: "buy", "sell", or "create".
    - **mint** (string) - Required - The mint address of the token.
    - **denominatedInSol** (boolean) - Required - Whether the amount is denominated in SOL.
    - **amount** (number) - Required - The amount to trade.
    - **slippage** (number) - Required - Slippage tolerance.
    - **priorityFee** (number) - Required - Priority fee for the transaction.
    - **pool** (string) - Required - The pool type, e.g., "pump".

### Response
#### Success Response (200)
- **encodedTransactions** (array) - An array of base58 encoded transaction bytes.
```

--------------------------------

### Subscription Methods

Source: https://pumpportal.fun/data-api/bonk-fun-data-api

Available subscription methods to receive specific event streams over the established WebSocket connection.

```APIDOC
## Subscription Methods

### Methods
- `subscribeNewToken`: Subscribe to token creation events (Free).
- `subscribeMigration`: Subscribe to token migration events (Free).
- `subscribeTokenTrade`: Subscribe to all trades for specific token(s) (Metered: 0.01 SOL per 10000 events).
- `subscribeAccountTrade`: Subscribe to all trades for specific account(s) (Metered: 0.01 SOL per 10000 events).

### Usage Note
Use a single WebSocket connection for all subscriptions. Sending multiple subscription messages over the same connection is required to avoid rate limiting or connection bans.
```

--------------------------------

### WebSocket Connection

Source: https://pumpportal.fun/data-api/bonk-fun-data-api

Establish a connection to the PumpPortal WebSocket server to begin receiving real-time data streams.

```APIDOC
## WebSocket Connection

### Endpoint
`wss://pumpportal.fun/api/data?api-key=your-api-key-here`

### Description
Connect to the PumpPortal WebSocket server to enable real-time data streaming. A valid API key is required for authentication.
```

--------------------------------

### Claim Creator Fees via Local Transaction API

Source: https://pumpportal.fun/creator-fee

Use the Local Transaction API to retrieve transaction bytes, sign them locally with your private key, and submit to an RPC endpoint.

```python
import requests  
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  
  
response = requests.post(url="https://pumpportal.fun/api/trade-local", data={  
    "publicKey": "Your public key here",  
    "action": "collectCreatorFee",  
    "priorityFee": 0.000001,  
})  
  
keypair = Keypair.from_base58_string("Your base 58 private key here")  
tx = VersionedTransaction(VersionedTransaction.from_bytes(response.content).message, [keypair])  
  
commitment = CommitmentLevel.Confirmed  
config = RpcSendTransactionConfig(preflight_commitment=commitment)  
txPayload = SendVersionedTransaction(tx, config)  
  
response = requests.post(  
    url="Your RPC Endpoint here - 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}')  
```

```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 sendPortalTransaction(){  
  const response = await fetch(`https://pumpportal.fun/api/trade-local`, {  
      method: "POST",  
      headers: {  
          "Content-Type": "application/json"  
      },  
      body: JSON.stringify({  
            "publicKey": "Your public key here",  
            "action": "collectCreatorFee",  
            "priorityFee": 0.000001,  
      })  
  });  
  if(response.status === 200){ // successfully generated transaction  
      const data = await response.arrayBuffer();  
      const tx = VersionedTransaction.deserialize(new Uint8Array(data));  
      const signerKeyPair = Keypair.fromSecretKey(bs58.decode("your-wallet-private-key"));  
      tx.sign([signerKeyPair]);  
      const signature = await web3Connection.sendTransaction(tx)  
      console.log("Transaction: https://solscan.io/tx/" + signature);  
  } else {  
      console.log(response.statusText); // log error  
  }  
}  
  
sendPortalTransaction();  
```

--------------------------------

### Execute Trade with JavaScript

Source: https://pumpportal.fun/trading-api

Uses the Fetch API to send a JSON-encoded POST request. Requires setting the Content-Type header to application/json.

```javascript
const response = await fetch("https://pumpportal.fun/api/trade?api-key=your-api-key-here", {  
    method: "POST",  
    headers: {  
        "Content-Type": "application/json"  
    },  
    body: JSON.stringify({  
        "action": "buy",            // "buy" or "sell"  
        "mint": "your CA here",     // contract address of the token you want to trade  
        "amount": 0.01,             // amount of SOL or tokens to trade  
        "denominatedInSol": "true", // "true" if amount is SOL, "false" if amount is tokens  
        "slippage": 10,             // percent slippage allowed  
        "priorityFee": 0.00005,       // amount to use as Jito tip or priority fee  
        "pool": "auto"              // exchange to trade on. "pump", "raydium", "pump-amm", "launchlab", "raydium-cpmm", "bonk" or "auto"  
    })  
});  
const data = await response.json();  // JSON object with tx signature or error(s)  
```
Tokens:
Raw