PumpDev

https://pumpdev.io
Admin
PumpDev is a complete Pump.fun API for developers providing trading bots, token creation, and fee...
Tokens:51,354
Snippets:343
Trust Score:3
Update:6 months ago
Show doc for...
Tokens:
Raw
### Lightning Setup

Source: https://pumpdev.io/lightning-bundle

Guide to setting up your Lightning wallet and obtaining an API key.

```APIDOC
## Lightning Setup

### Description
This section details the process of creating or importing a Lightning wallet and retrieving your unique API key, which is essential for interacting with the Lightning Bundle API.

### Endpoint
N/A (Setup process)

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Quick Start: Connect and Subscribe to New Token Launches

Source: https://pumpdev.io/data-api

Connect to the WebSocket, subscribe to new token launch notifications, and start receiving events. This example uses the 'ws' library for Node.js.

```javascript
import WebSocket from 'ws';  
  
const ws = new WebSocket('wss://pumpdev.io/ws');  
ws.on('open', () => ws.send(JSON.stringify({ method: 'subscribeNewToken' })));  
ws.on('message', (data) => console.log(JSON.parse(data.toString())));  

```

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

### Install SDK Dependencies

Source: https://pumpdev.io/welcome

Required packages for interacting with the Solana blockchain and handling keys.

```bash
npm install @solana/web3.js bs58  
```

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

### Automated Bot Example with WebSocket

Source: https://pumpdev.io/lightning-trade

This comprehensive example combines WebSocket for real-time token creation events and the Lightning API for automated buying. It requires installing the 'ws' package. Ensure your API key is kept secure.

```javascript
import WebSocket from 'ws';

const API_URL = 'https://pumpdev.io';
const WS_URL = 'wss://pumpdev.io/ws';
const API_KEY = 'pk_xxxxxxxxxxxxxxxx';

const BUY_AMOUNT_SOL = 0.01;
const MAX_MARKET_CAP_SOL = 50;

let isBuying = false;

const ws = new WebSocket(WS_URL);

ws.on('open', () => {
  ws.send(JSON.stringify({ method: 'subscribeNewToken' }));
  console.log('Watching for new tokens...');
});

ws.on('message', async (data) => {
  const event = JSON.parse(data.toString());

  if (event.txType === 'create' && event.marketCapSol <= MAX_MARKET_CAP_SOL && !isBuying) {
    console.log(`New token: ${event.name} (${event.symbol})`);
    await buyToken(event.mint);
  }
});

async function buyToken(mint) {
  isBuying = true;
  try {
    const response = await fetch(
      `${API_URL}/api/trade-lightning?api-key=${API_KEY}`,
      {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          action: 'buy',
          mint: mint,
          amount: BUY_AMOUNT_SOL
        })
      }
    );

    const result = await response.json();
    if (result.signature) {
      console.log('Buy executed:', result.signature);
    } else {
      console.log('Error:', result.error);
    }
  } catch (err) {
    console.error('Error:', err.message);
  } finally {
    isBuying = false;
  }
}
```

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

### Sell Exact Token Amount Example

Source: https://pumpdev.io/lightning-trade

This example shows how to sell a precise number of tokens. Set `denominatedInSol` to 'false' and provide the exact token amount.

```javascript
body: JSON.stringify({
  action: 'sell',
  mint: 'TokenMintAddress',
  amount: 1000000,
  denominatedInSol: 'false'
})
```

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

### Sell 100% of Tokens Example

Source: https://pumpdev.io/lightning-trade

This example demonstrates how to sell all of your tokens for a given mint address. The amount is specified as '100%'.

```javascript
const response = await fetch( 
  'https://pumpdev.io/api/trade-lightning?api-key=YOUR_KEY', 
  { 
    method: 'POST', 
    headers: { 'Content-Type': 'application/json' }, 
    body: JSON.stringify({ 
      action: 'sell', 
      mint: 'TokenMintAddress', 
      amount: '100%' 
    }) 
  } 
);
const { signature } = await response.json();
```

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

### Connect and Subscribe to PumpDev WebSocket in Python

Source: https://pumpdev.io/data-api

Demonstrates how to connect to the WebSocket and process new token launch events. Requires the 'websockets' library installed via 'pip install websockets'.

```python
import asyncio  
import json  
import websockets  
  
WS_URL = "wss://pumpdev.io/ws"  
  
async def main():  
    async with websockets.connect(WS_URL) as ws:  
        # Subscribe to new token launches  
        await ws.send(json.dumps({"method": "subscribeNewToken"}))  
  
        async for message in ws:  
            event = json.loads(message)  
  
            if event.get("txType") == "create":  
                print(f"New token: {event['name']} ({event['symbol']})")  
                print(f"  Mint: {event['mint']}")  
                print(f"  Creator: {event['traderPublicKey']}")  
                print(f"  Initial buy: {event.get('initialBuy', 0)} tokens / {event.get('solAmount', 0)} SOL")  
            elif event.get("txType") in ("buy", "sell"):  
                src = f" [{event['source']}]" if "source" in event else ""  
                print(f"{event['txType'].upper()}{src}: {event['solAmount']} SOL — {event['mint']}")  
                print(f"  Market Cap: {event.get('marketCapSol', 0):.2f} SOL")  
            elif event.get("txType") == "complete":  
                print(f"MIGRATION: {event['mint']} bonding curve completed")  
            elif event.get("txType") == "create_pool":  
                print(f"POOL CREATED: {event['mint']} -> {event.get('pool')}")  
  
asyncio.run(main())
```

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

### Buy Token Example

Source: https://pumpdev.io/lightning-trade

Use this snippet to buy a specified amount of a token. Ensure you have the correct API key and token mint address.

```javascript
const response = await fetch( 
  'https://pumpdev.io/api/trade-lightning?api-key=YOUR_KEY', 
  { 
    method: 'POST', 
    headers: { 'Content-Type': 'application/json' }, 
    body: JSON.stringify({ 
      action: 'buy', 
      mint: 'TokenMintAddress', 
      amount: 0.1 
    }) 
  } 
);
const { signature } = await response.json();
console.log('Buy executed:', signature);
```

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

### API Response Structures

Source: https://pumpdev.io/lightning-bundle

Example JSON response formats for general bundle operations and token creation requests.

```json
{
  "results": [  
    { "type": "buy", "signature": "5x7...", "publicKey": "...", "error": null },  
    { "type": "sell", "signature": "3k9...", "publicKey": "...", "error": null }  
  ],  
  "mint": "TokenMintAddress"  
}
```

```json
{
  "type": "create",  
  "signature": "4j2...",  
  "publicKey": "...",  
  "mint": "NewTokenMintAddress",  
  "metadataUri": "https://pumpdev.io/metadata/uuid.json",  
  "error": null  
}
```

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

### Execute Partial Token Sells

Source: https://pumpdev.io/trade-api

Examples for selling a specific percentage or an exact quantity of tokens instead of the entire position.

```typescript
// Sell 50% of tokens  
const response = await fetch(`${API_URL}/api/trade-local`, {  
  method: 'POST',  
  headers: { 'Content-Type': 'application/json' },  
  body: JSON.stringify({  
    publicKey: publicKey,  
    action: 'sell',  
    mint: 'TokenMintAddress',  
    amount: '50%',              // Sell half  
    denominatedInSol: 'false',  
    slippage: 15  
  })  
});  
  
// Or sell exact token amount  
const response2 = await fetch(`${API_URL}/api/trade-local`, {  
  method: 'POST',  
  headers: { 'Content-Type': 'application/json' },  
  body: JSON.stringify({  
    publicKey: publicKey,  
    action: 'sell',  
    mint: 'TokenMintAddress',  
    amount: 1000000,            // Sell 1,000,000 tokens  
    denominatedInSol: 'false',  
    slippage: 15  
  })  
});
```

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

### New Token Launch Event Structure

Source: https://pumpdev.io/data-api

Example of the JSON payload received when a new token is launched. Includes details about the token, creator, and initial bonding curve parameters.

```json
{
  "signature": "3hJ7...",
  "mint": "NewTokenMint",
  "traderPublicKey": "CreatorWallet",
  "txType": "create",
  "name": "Token Name",
  "symbol": "TKN",
  "uri": "https://metadata-uri",
  "initialBuy": 100000000,
  "solAmount": 1,
  "bondingCurveKey": "BondingCurveAddress",
  "vTokensInBondingCurve": 900000000,
  "vSolInBondingCurve": 31,
  "marketCapSol": 32.7
}

```

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

### Buy Token with Lightning API (Server-Side)

Source: https://pumpdev.io/

Use this server-side endpoint for a single HTTP call to buy tokens. No wallet setup or signing is required on the client.

```javascript
// One HTTP call to trade on Pump.fun
const res = await fetch(
  'https://pumpdev.io/api/trade-lightning?api-key=YOUR_API_KEY',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      action: 'buy',
      mint: 'TokenMintAddress',
      amount: 0.1,
    })
  }
);

const { signature } = await res.json();
```

```javascript
// One HTTP call = done
const res = await fetch(
  'https://pumpdev.io/api/trade-lightning?api-key=YOUR_KEY',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      action: 'buy',
      mint: 'TokenMintAddress',
      amount: 0.1,
      denominatedInSol: 'true',
    })
  }
);

const { signature } = await res.json();
console.log('Done!', signature);
```

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

### Sell 50% of Tokens Example

Source: https://pumpdev.io/lightning-trade

Use this snippet to sell half of your tokens for a specific mint address. The amount is set to '50%'.

```javascript
body: JSON.stringify({
  action: 'sell',
  mint: 'TokenMintAddress',
  amount: '50%'
})
```

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

### Jito Tip Recommendations

Source: https://pumpdev.io/jito-bundles

Recommended Jito tips for different scenarios to ensure faster bundle landing.

```APIDOC
## Jito Tip Recommendations

The Jito tip incentivizes validators to include your bundle. Higher tips = faster landing.

| Scenario                  | Recommended Tip | Notes                     |
| ------------------------- | --------------- | ------------------------- |
| Token creation + dev buy  | 0.01 SOL        | Standard priority         |
| Multi-buyer launch        | 0.02 - 0.05 SOL | Higher tip for larger bundles |
| Trade bundle (2-3 wallets)| 0.01 SOL        | Standard priority         |
| High-priority sniper      | 0.05+ SOL       | Competitive landing       |
| Low urgency               | 0.005 SOL       | Minimum viable tip        |

### Tip Distribution

For `/api/create-bundle`, the Jito tip is automatically **split across transactions** to stay within Solana's per-transaction limits. For `/api/trade-bundle`, the tip is applied only to the **last transaction** in the bundle.
```

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

### Best Practices

Source: https://pumpdev.io/jito-bundles

Recommended practices for using Jito bundles effectively.

```APIDOC
## Best Practices

1. **Fund all wallets first** — Every wallet in the bundle needs enough SOL for its transaction + fees
2. **Use unique wallets** — Duplicate wallets produce duplicate tx hashes that Jito rejects
3. **Send to multiple Jito endpoints** — Increases landing probability
4. **Set reasonable slippage** — 25-50% for new token launches, 10-15% for established tokens
5. **Choose appropriate tips** — Higher tips during congestion, lower during calm periods
6. **Check bundle status** — Use `getBundleStatuses` to verify execution
7. **Test on devnet first** — Validate your signing and bundle flow before mainnet
```

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

### Create Token and Buy with Multiple Wallets

Source: https://pumpdev.io/lightning-bundle

Use this bundle to atomically create a token and have multiple wallets buy into it. Ensure the token is created on-chain before attempting to sell.

```javascript
const API_URL = 'https://pumpdev.io';
const CREATOR_KEY = 'pk_creator_xxxxxxxx';
const BUYER1_KEY = 'pk_buyer1_xxxxxxxx';
const BUYER2_KEY = 'pk_buyer2_xxxxxxxx';

// 1. Create token + buy from 4 wallets (atomic via Jito)
const createRes = await fetch(
  `${API_URL}/api/bundle-lightning`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      accounts: [
        {
          apiKey: CREATOR_KEY, type: 'create',
          name: 'My Token', symbol: 'MTK',
          image: 'https://example.com/logo.png'
        },
        { apiKey: CREATOR_KEY, type: 'buy', amount: 1.0, denominatedInSol: 'true' },
        { apiKey: BUYER1_KEY, type: 'buy', amount: 0.5, denominatedInSol: 'true' },
        { apiKey: BUYER2_KEY, type: 'buy', amount: 0.5, denominatedInSol: 'true' },
      ],
      jitoTip: 0.02
    })
  }
);
const { mint, results } = await createRes.json();
console.log(`Token launched: https://pump.fun/${mint}`);
console.log(`${results.filter(r => r.signature).length}/${results.length} succeeded`);
```

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

### WebSocket Confirmation Message Formats

Source: https://pumpdev.io/data-api

Examples of JSON messages received upon successful connection or subscription.

```json
{
  "type": "connected",
  "message": "Connected to PumpDev WebSocket"
}
```

```json
{
  "type": "subscribed",
  "method": "subscribeTokenTrade",
  "keys": ["TokenMint1", "TokenMint2"]
}
```

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

### Handle API Error Response

Source: https://pumpdev.io/claim-cashback

Example of the JSON error structure returned by the API when a request fails.

```json
{
  "error": "No cashback available for this wallet"
}
```

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

### Create Token and Buy

Source: https://pumpdev.io/lightning-bundle

Launch a new token and execute a buy order in the same atomic block.

```javascript
const response = await fetch(  
  'https://pumpdev.io/api/bundle-lightning',  
  {  
    method: 'POST',  
    headers: { 'Content-Type': 'application/json' },  
    body: JSON.stringify({  
      accounts: [  
        {  
          apiKey: 'YOUR_KEY', type: 'create',  
          name: 'pumpdev.io', symbol: 'pumpdev.io',  
          image: 'https://pumpdev.io/img/logo.jpg',  
          twitter: 'https://x.com/MyToken',  
          website: 'http://pumpdev.io/'  
        },  
        { apiKey: 'YOUR_KEY', type: 'buy', amount: 0.5, denominatedInSol: 'true' }  
      ],  
      jitoTip: 0.01  
    })  
  }  
);  
const { results, mint } = await response.json();  
console.log(`Token launched: https://pump.fun/${mint}`);  
console.log('Create sig:', results[0].signature);  
console.log('Buy sig:', results[1].signature);
```

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

### Handle API Error Responses

Source: https://pumpdev.io/trade-api

Example of the structured JSON error format returned by the API when a request fails.

```json
{
  "error": "publicKey is required"
}
```

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

### POST /api/create-bundle

Source: https://pumpdev.io/welcome

Execute an atomic launch using Jito bundles, allowing the creator and additional buyers to enter the same block.

```APIDOC
## POST /api/create-bundle

### Description
Atomic launch with creator + up to 3 additional buyers in the same block.

### Method
POST

### Endpoint
/api/create-bundle

### Request Body
- **publicKey** (string) - Required - Creator's public key
- **name** (string) - Required - Token name
- **symbol** (string) - Required - Token symbol
- **uri** (string) - Required - Metadata URI
- **buyAmountSol** (number) - Required - Creator buy amount
- **jitoTip** (number) - Required - Jito tip amount
- **additionalBuyers** (array) - Required - List of objects containing publicKey and amountSol
```

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

### POST /api/create - Create + Dev Buy

Source: https://pumpdev.io/jito-bundles

Splits token creation and a developer buy into a Jito bundle for faster landing.

```APIDOC
## POST /api/create

### Description
Splits token creation and a developer buy into a Jito bundle for faster landing.

### Method
POST

### Endpoint
/api/create

### Parameters
#### Request Body
- **accounts** (array) - Required - An array of account actions, typically including 'create' and 'buy'.
  - **publicKey** (string) - Required - The wallet public key.
  - **type** (string) - Required - The type of action ('create' or 'buy').
  - **amount** (number) - Optional - The amount for the buy action.
  - **denominatedInSol** (string) - Optional - Whether the amount is denominated in SOL ('true' or 'false').
- **mint** (string) - Required - The token mint address.
- **jitoTip** (number) - Required - The Jito tip amount.
- **metadataUri** (string) - Required - The URI for the token's metadata.

### Request Example
```json
{
  "accounts": [
    { "publicKey": "CreatorPublicKey", "type": "create" },
    { "publicKey": "CreatorPublicKey", "type": "buy", "amount": 0.1, "denominatedInSol": "true" }
  ],
  "mint": "TokenMintAddress",
  "jitoTip": 0.01,
  "metadataUri": "https://example.com/metadata.json"
}
```

### Response
#### Success Response (200)
- **transactions** (array) - An array of unsigned transactions.
  - **transaction** (string) - The base58 encoded unsigned transaction.
  - **signers** (array) - An array of public keys that need to sign the transaction.
  - **type** (string) - The type of transaction ('create' or 'buy').
  - **publicKey** (string) - The public key associated with the transaction.
  - **mint** (string) - The token mint address (for create transaction).
  - **metadataUri** (string) - The metadata URI (for create transaction).
  - **error** (null) - Should be null on success.
- **mint** (string) - The token mint address.
- **mintSecretKey** (string) - The base58 encoded mint secret key.

#### Response Example
```json
{
  "transactions": [
    {
      "transaction": "base58_unsigned_tx_create",
      "signers": ["CreatorPublicKey", "MintPublicKey"],
      "type": "create",
      "publicKey": "CreatorPublicKey",
      "mint": "MintPublicKey",
      "metadataUri": "https://example.com/metadata.json"
    },
    {
      "transaction": "base58_unsigned_tx_buy",
      "signers": ["CreatorPublicKey"],
      "type": "buy",
      "publicKey": "CreatorPublicKey"
    }
  ],
  "mint": "MintPublicKey",
  "mintSecretKey": "base58_mint_secret_key"
}
```
```

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

### POST /api/create-bundle - Multi-Buyer Launch

Source: https://pumpdev.io/jito-bundles

Allows a creator and up to three additional buyers to atomically launch a token in a single bundle.

```APIDOC
## POST /api/create-bundle

### Description
Creator + up to 3 additional buyers atomically launch a token.

### Method
POST

### Endpoint
/api/create-bundle

### Parameters
#### Request Body
- **accounts** (array) - Required - An array of account actions, including creator and buyers.
  - **publicKey** (string) - Required - The wallet public key.
  - **type** (string) - Required - The type of action ('create' or 'buy').
  - **amount** (number) - Optional - The amount for the buy action.
  - **denominatedInSol** (string) - Optional - Whether the amount is denominated in SOL ('true' or 'false').
- **mint** (string) - Required - The token mint address.
- **jitoTip** (number) - Required - The Jito tip amount.
- **metadataUri** (string) - Required - The URI for the token's metadata.

### Request Example
```json
{
  "accounts": [
    { "publicKey": "CreatorPublicKey", "type": "create" },
    { "publicKey": "CreatorPublicKey", "type": "buy", "amount": 0.1, "denominatedInSol": "true" },
    { "publicKey": "Buyer1PublicKey", "type": "buy", "amount": 0.2, "denominatedInSol": "true" },
    { "publicKey": "Buyer2PublicKey", "type": "buy", "amount": 0.3, "denominatedInSol": "true" }
  ],
  "mint": "TokenMintAddress",
  "jitoTip": 0.01,
  "metadataUri": "https://example.com/metadata.json"
}
```

### Response
#### Success Response (200)
- **transactions** (array) - An array of unsigned transactions.
  - **transaction** (string) - The base58 encoded unsigned transaction.
  - **signers** (array) - An array of public keys that need to sign the transaction.
  - **type** (string) - The type of transaction ('create' or 'buy').
  - **publicKey** (string) - The public key associated with the transaction.
  - **mint** (string) - The token mint address (for create transaction).
  - **metadataUri** (string) - The metadata URI (for create transaction).
  - **error** (null) - Should be null on success.
- **mint** (string) - The token mint address.
- **mintSecretKey** (string) - The base58 encoded mint secret key.

#### Response Example
```json
{
  "transactions": [
    {
      "transaction": "base58_unsigned_tx_create",
      "signers": ["CreatorPublicKey", "MintPublicKey"],
      "type": "create",
      "publicKey": "CreatorPublicKey",
      "mint": "MintPublicKey",
      "metadataUri": "https://example.com/metadata.json"
    },
    {
      "transaction": "base58_unsigned_tx_buyer1",
      "signers": ["Buyer1PublicKey"],
      "type": "buy",
      "publicKey": "Buyer1PublicKey"
    },
    {
      "transaction": "base58_unsigned_tx_buyer2",
      "signers": ["Buyer2PublicKey"],
      "type": "buy",
      "publicKey": "Buyer2PublicKey"
    }
  ],
  "mint": "MintPublicKey",
  "mintSecretKey": "base58_mint_secret_key"
}
```
```

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

### POST /api/trade-bundle

Source: https://pumpdev.io/jito-bundles

Builds multiple buy or sell transactions in a single API call. Each wallet gets its own transaction, and the last transaction receives the Jito tip.

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

### Description
Use this endpoint to build multiple buy or sell transactions in a single API call. Each wallet associated with the transaction will have its own transaction, and the final transaction in the sequence will receive the Jito tip.

### Method
POST

### Endpoint
/api/trade-bundle

### Parameters
#### Request Body
- **accounts** (array) - Required - Array of `{ publicKey, name }` objects representing the wallets involved.
- **action** (string) - Required - The type of action to perform, either `"buy"` or `"sell"`.
- **mint** (string) - Required - The token mint address for the trade.
- **amount** (number/string) - Required - The trade amount. For buys, this is typically in SOL. For sells, it can be `"100%"` or a specific token amount.
- **denominatedInSol** (string) - Required - Set to `"true"` if the `amount` is denominated in SOL.
- **slippage** (number) - Optional - The maximum acceptable slippage percentage. Defaults to 10.
- **priorityFee** (number) - Optional - The priority fee in SOL. Defaults to 0.0005.
- **jitoTip** (number) - Optional - The Jito tip amount, applied only to the last transaction. Defaults to 0.
- **creator** (string) - Optional - The creator's public key. If provided, it skips the bonding curve lookup for faster processing.

### Request Example
```json
{
  "accounts": [
    { "publicKey": "CREATOR_KEY", "name": "creator" },
    { "publicKey": "WALLET1_KEY", "name": "wallet1" },
    { "publicKey": "WALLET2_KEY", "name": "wallet2" }
  ],
  "action": "buy",
  "mint": "MINT_ADDRESS",
  "amount": 0.5,
  "denominatedInSol": "true",
  "slippage": 15,
  "jitoTip": 0.01
}
```

### Response
#### Success Response (200)
- **transactions** (array) - An array of transaction objects, each containing `name`, `transaction` (base58 encoded string), and `error` (null if successful).
- **stats** (object) - Statistics about the transaction processing, including `total`, `success`, `failed`, and `durationMs`.

#### Response Example
```json
{
  "transactions": [
    { "name": "creator", "transaction": "base58...", "error": null },
    { "name": "wallet1", "transaction": "base58...", "error": null },
    { "name": "wallet2", "transaction": "base58...", "error": null }
  ],
  "stats": {
    "total": 3,
    "success": 3,
    "failed": 0,
    "durationMs": 45
  }
}
```

### Notes
- Each account in the `accounts` array must use a unique wallet. Identical wallets will result in duplicate transaction message hashes, which Jito rejects.
```

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

### Execute a Jito Bundle Multi-Wallet Launch

Source: https://pumpdev.io/welcome

Perform an atomic token launch that includes the creator and additional buyers in a single block.

```javascript
const response = await fetch(`${API_URL}/api/create-bundle`, {  
  method: 'POST',  
  headers: { 'Content-Type': 'application/json' },  
  body: JSON.stringify({  
    publicKey: creator.publicKey.toBase58(),  
    name: 'Bundled Token',  
    symbol: 'BUND',  
    uri: metadataUri,  
    buyAmountSol: 1.0,  
    jitoTip: 0.02,  
    additionalBuyers: [  
      { publicKey: buyer1.publicKey.toBase58(), amountSol: 2.0 },  
      { publicKey: buyer2.publicKey.toBase58(), amountSol: 1.5 }  
    ]  
  })  
});
```

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

### POST /api/create-bundle

Source: https://pumpdev.io/jito-bundles

Initiates a bundle request to create a token and execute multiple buy transactions atomically.

```APIDOC
## POST /api/create-bundle

### Description
Launches a token with multiple wallets buying atomically in the same block.

### Method
POST

### Endpoint
/api/create-bundle

### Parameters
#### Request Body
- **publicKey** (string) - Required - Creator wallet public key
- **name** (string) - Required - Token name (max 32 chars)
- **symbol** (string) - Required - Token symbol (max 10 chars)
- **uri** (string) - Required - Metadata URI
- **buyAmountSol** (number) - Required - Creator's buy amount in SOL
- **slippage** (number) - Optional - Slippage % (default: 30)
- **jitoTip** (number) - Optional - Jito tip in SOL (default: 0.01)
- **mintKeypair** (string) - Optional - Base58 mint secret key
- **additionalBuyers** (array) - Optional - Up to 3 additional buyers
- **cashbackEnabled** (boolean) - Optional - Enable cashback rewards

### Request Example
{
  "publicKey": "CreatorWalletPublicKey",
  "name": "Bundled Token",
  "symbol": "BUND",
  "uri": "ipfs://...",
  "buyAmountSol": 1.0,
  "slippage": 30,
  "jitoTip": 0.02,
  "additionalBuyers": [
    { "publicKey": "BuyerWalletPublicKey", "amountSol": 0.5 }
  ]
}

### Response
#### Success Response (200)
- **mint** (string) - The generated token mint address
- **mintSecretKey** (string) - The base58 encoded mint secret key
- **transactions** (array) - List of serialized transactions and required signers

#### Response Example
{
  "mint": "TokenMintAddress",
  "mintSecretKey": "Base58SecretKey",
  "transactions": [
    { "transaction": "base58_encoded_tx", "signers": ["creator", "mint"] }
  ]
}
```

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

### API Response Structure

Source: https://pumpdev.io/lightning-trade

This is an example of the JSON response structure you can expect after a successful trade request. It includes the transaction signature, token mint address, action performed, and your public key.

```json
{
  "signature": "5x7...",
  "mint": "TokenMintAddress",
  "action": "buy",
  "publicKey": "YourWalletPublicKey"
}
```

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

### POST /api/create

Source: https://pumpdev.io/welcome

Launch a new token on Pump.fun with an optional initial developer buy.

```APIDOC
## POST /api/create

### Description
Launch your own token with optional dev buy.

### Method
POST

### Endpoint
/api/create

### Request Body
- **publicKey** (string) - Required - Creator's public key
- **name** (string) - Required - Token name
- **symbol** (string) - Required - Token symbol
- **uri** (string) - Required - Metadata URI
- **buyAmountSol** (number) - Optional - Initial dev buy amount in SOL
- **slippage** (number) - Optional - Slippage tolerance
- **jitoTip** (number) - Optional - Jito tip amount

### Response
#### Success Response (200)
- **mint** (string) - The mint address of the created token

#### Response Example
{
  "mint": "TokenMintAddress"
}
```

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

### Lightning Bundle API Request Body

Source: https://pumpdev.io/lightning-bundle

This is an example of the JSON request body for the Lightning Bundle API. It includes accounts for transactions, a mint address, Jito tip, slippage, and priority fee.

```json
{
  "accounts": [
    { "apiKey": "key1", "type": "buy", "amount": 0.1, "denominatedInSol": "true" },
    { "apiKey": "key2", "type": "sell", "amount": "100%" }
  ],
  "mint": "TokenMintAddress",
  "jitoTip": 0.01,
  "slippage": 90,
  "priorityFee": 0.0005
}
```

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

### Launch Token with Multi-Buyer Bundle

Source: https://pumpdev.io/jito-bundles

Use this function to launch a token with multiple wallets buying atomically. It requests a bundle from the API, signs each transaction with the correct signer, and sends the bundle via Jito.

```javascript
async function multiBuyerLaunch(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: 'Bundled Token',
      symbol: 'BUND',
      uri: metadataUri,
      buyAmountSol: 1.0,          // Creator buys 1 SOL
      slippage: 30,
      jitoTip: 0.02,              // Tip split across transactions
      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 the correct signer
  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}`);
}
```

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

### POST /api/create-bundle

Source: https://pumpdev.io/

Facilitates token creation using Jito bundles for atomic multi-buyer launches, ensuring atomicity and efficiency.

```APIDOC
## POST /api/create-bundle

### Description
Launch pump.fun tokens using Jito bundles. This method ensures atomic multi-buyer launches, providing efficiency and reliability for token creation.

### Method
POST

### Endpoint
/api/create-bundle

### Request Body
(Details on request body fields for creating tokens with Jito bundles are expected here.)

### Response
(Details on the response, likely including transaction confirmation or bundle status, are expected here.)
```

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

### Complete Event Example

Source: https://pumpdev.io/data-api

This JSON object represents a 'complete' trade event, indicating a bonding curve is full and migration is beginning. It includes common trade fields and bonding curve specific fields.

```json
{
  "signature": "4kR2...",
  "mint": "TokenMintAddress",
  "traderPublicKey": "MigratorWallet",
  "txType": "complete",
  "bondingCurveKey": "BondingCurveAddress",
  "timestamp": 1743782400
}
```

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

### PumpSwap AMM Trade Event Structure

Source: https://pumpdev.io/data-api

Example of the JSON payload received for a PumpSwap AMM trade event after token migration. Includes similar details to bonding curve trades, plus pool information.

```json
{
  "signature": "2gT7...",
  "mint": "TokenMintAddress",
  "traderPublicKey": "TraderWallet",
  "txType": "buy",
  "solAmount": 0.8127,
  "tokenAmount": 2116283,
  "pool": "PoolAddress",
  "source": "pumpswap",
  "poolBaseReserves": 800000000000,
  "poolQuoteReserves": 25000000000,
  "marketCapSol": 380.26
}

```

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

### Create a Token on Pump.fun

Source: https://pumpdev.io/welcome

Launch a new token using the /api/create endpoint, with support for an optional developer buy.

```javascript
const response = await fetch(`${API_URL}/api/create`, {  
  method: 'POST',  
  headers: { 'Content-Type': 'application/json' },  
  body: JSON.stringify({  
    publicKey: creator.publicKey.toBase58(),  
    name: 'My Token',  
    symbol: 'MTK',  
    uri: 'https://ipfs.io/ipfs/YOUR_METADATA',  
    buyAmountSol: 0.5,    // Optional dev buy  
    slippage: 30,  
    jitoTip: 0.01  
  })  
});  
  
const result = await response.json();  
console.log(`Token: https://pump.fun/${result.mint}`);
```

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

### Trade Bundle Response Structure

Source: https://pumpdev.io/jito-bundles

This is an example of the JSON response structure received after a trade bundle request. It includes a list of transactions, each with a name, the base58 encoded transaction, and any errors. It also provides statistics about the bundle processing.

```json
{
  "transactions": [
    { "name": "creator", "transaction": "base58...", "error": null },
    { "name": "wallet1", "transaction": "base58...", "error": null },
    { "name": "wallet2", "transaction": "base58...", "error": null }
  ],
  "stats": {
    "total": 3,
    "success": 3,
    "failed": 0,
    "durationMs": 45
  }
}
```

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

### POST /api/create-bundle - Jito Bundle Multi-Buyer Launch

Source: https://pumpdev.io/create-token

Launch tokens with multiple buyers in the same block using Jito bundles for atomic execution and to prevent front-running. Supports up to 4 wallets (creator + 3 additional buyers).

```APIDOC
## POST /api/create-bundle

### Description
Create a pump.fun token with multiple buyers in the same block using Jito bundles. This ensures atomic execution and prevents front-running, allowing for coordinated launches.

### Method
POST

### Endpoint
/api/create-bundle

### Parameters
#### Request Body
- **publicKey** (string) - Required - Creator wallet public key
- **name** (string) - Required - Token name
- **symbol** (string) - Required - Token symbol
- **uri** (string) - Required - Metadata URI
- **buyAmountSol** (number) - Required - Creator's buy amount in SOL
- **slippage** (number) - Optional - Slippage % (default: 30)
- **jitoTip** (number) - Optional - Jito tip in SOL (default: 0.01)
- **mintKeypair** (string) - Optional - Base58 mint secret key (auto-generated if omitted)
- **additionalBuyers** (array) - Optional - Up to 3 additional buyers. Each object should have `publicKey` (string) and `amountSol` (number).

### Additional Buyer Object
```json
{
  "publicKey": "BuyerWalletPublicKey",
  "amountSol": 0.5
}
```

### Request Example
```json
{
  "publicKey": "CREATOR_PUBLIC_KEY",
  "name": "Coordinated Launch Token",
  "symbol": "CLT",
  "uri": "https://arweave.net/ANOTHER_METADATA_HASH",
  "buyAmountSol": 1.0,
  "additionalBuyers": [
    { "publicKey": "BUYER1_PUBLIC_KEY", "amountSol": 0.5 },
    { "publicKey": "BUYER2_PUBLIC_KEY", "amountSol": 0.5 }
  ],
  "jitoTip": 0.02
}
```

### Response
#### Success Response (200)
- **transactions** (array) - Array of transactions forming the Jito bundle.
  - **transaction** (string) - Base58-encoded transaction.
  - **signers** (array) - Signers required for the transaction.
  - **description** (string) - Description of the transaction step (e.g., "Create token", "Dev buy", "Additional buyer 1 buy").
- **mint** (string) - Token Mint PublicKey.
- **mintSecretKey** (string) - Base58 mint secret key.

#### Response Example
```json
{
  "transactions": [
    { "transaction": "base58...", "signers": ["creator", "mint"], "description": "Create token" },
    { "transaction": "base58...", "signers": ["creator"], "description": "Creator buy" },
    { "transaction": "base58...", "signers": ["buyer1"], "description": "Additional buyer 1 buy" }
  ],
  "mint": "TokenMintPublicKey",
  "mintSecretKey": "base58MintSecretKey"
}
```
```

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

### Create Pool Event Example

Source: https://pumpdev.io/data-api

This JSON object represents a 'create_pool' trade event, signifying the creation of a PumpSwap AMM pool after a bonding curve migration. It includes common trade fields and PumpSwap AMM specific fields.

```json
{
  "signature": "7jKs...",
  "mint": "TokenMintAddress",
  "txType": "create_pool",
  "pool": "NewPoolAddress",
  "traderPublicKey": "CreatorWallet",
  "baseMint": "TokenMintAddress",
  "quoteMint": "So11111111111111111111111111111111111111112",
  "source": "pumpswap",
  "poolBaseReserves": 206900000000000,
  "poolQuoteReserves": 85000000000
}
```

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

### Bonding Curve Trade Event Structure

Source: https://pumpdev.io/data-api

Example of the JSON payload received for a bonding curve trade event. Includes details like signature, mint address, trader, transaction type, amounts, and bonding curve information.

```json
{
  "signature": "5xK9...",
  "mint": "TokenMintAddress",
  "traderPublicKey": "TraderWallet",
  "txType": "buy",
  "solAmount": 0.5,
  "tokenAmount": 1000000,
  "bondingCurveKey": "BondingCurveAddress",
  "vTokensInBondingCurve": 900000000,
  "vSolInBondingCurve": 35,
  "marketCapSol": 40.5
}

```
Tokens:
Raw