PumpApi

https://pumpapi.io/
Admin
PumpApi is the fastest and simplest API for trading on Pump.fun, Raydium Launchpad, Meteora...
Tokens:50,185
Snippets:208
Trust Score:4.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Create Token and Buy with Multiple Wallets (JavaScript)

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

This JavaScript example uses Axios to create a token and then have multiple wallets buy it. It demonstrates a similar workflow to the Python example, suitable for Node.js or browser environments. Ensure Axios is installed.

```javascript
import axios from 'axios';

const data = {
  jitoTip: 0.0001,
  transactions: [
    {
      privateKey: "dev_wallet_private_key",
      action: "create",
      name: "PumpApi",
      symbol: "PAPI",
      description: "Fast API for Pump.fun, Raydium, Meteora",
      imageURL: "https://pumpapi.io/img/pumpapi_logo.webp",
      website: "https://pumpapi.io",
      telegram: "https://t.me/YOUR_TG",
      x: "https://x.com/realpumpapi",
      mintRef: "0", // set a temporary reference for the new token
      initialTradeAction: "buy", // dev buy
      amount: 0.5,
      denominatedInQuote: true,
      slippage: 99,
    },
    {
      privateKey: "wallet_2_private_key",
      action: "buy",
      mintRef: "0", // reuse the mintRef we set during create
      amount: 0.3,
      denominatedInQuote: true,
      slippage: 99,
    },
    {
      privateKey: "wallet_3_private_key",
      action: "buy",
      mintRef: "0", // reuse the mintRef we set during create
      amount: 0.3,
      denominatedInQuote: true,
      slippage: 99,
    },
    {
      privateKey: "wallet_4_private_key",
      action: "buy",
      mintRef: "0", // reuse the mintRef we set during create
      amount: 0.3,
      denominatedInQuote: true,
      slippage: 99,
    },
    {
      privateKey: "wallet_5_private_key",
      action: "buy",
      mintRef: "0", // reuse the mintRef we set during create
      amount: 0.3,
      denominatedInQuote: true,
      slippage: 99,
    }
  ]
};

axios.post("https://api.pumpapi.io", data)
  .then(response => console.log(response.data))
  .catch(error => console.error(error));
```

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

### Raydium Launchpad (Bonk) Pool Buy Example

Source: https://pumpapi.io/stream

This example demonstrates a 'buy' transaction within a Raydium Launchpad pool, specifically mentioning the 'bonk' platform.

```APIDOC
## Transaction Data (Raydium Launchpad Buy)

### Description
Details of a 'buy' transaction in a Raydium Launchpad pool, potentially using Bonk as a platform.

### Method
POST

### Endpoint
`/api/transactions`

### Parameters
#### Request Body
- **signature** (string) - The transaction signature.
- **txType** (string) - Type of transaction, "buy".
- **poolId** (string) - The unique identifier for the liquidity pool.
- **mint** (string) - The mint address of the token being bought.
- **quoteMint** (string) - The mint address of the quote token used for purchase.
- **txSigner** (string) - The address of the transaction signer.
- **tokenAmount** (number) - The amount of tokens bought.
- **quoteAmount** (number) - The amount of quote tokens spent.
- **tokensInPool** (number) - The total number of base tokens currently in the pool.
- **quoteInPool** (number) - The total amount of quote tokens currently in the pool.
- **vTokensInBondingCurve** (number) - Virtual tokens in the bonding curve.
- **vSolInBondingCurve** (number) - Virtual SOL in the bonding curve.
- **price** (number) - The price of the token at the time of purchase.
- **marketCapQuote** (number) - The market capitalization based on the quote token.
- **poolFeeRate** (number) - The fee rate for the pool.
- **pool** (string) - The type of pool, "raydium-launchpad".
- **platform** (string) - The platform used, e.g., "bonk".
- **launchpadConfig** (string) - Configuration details for the launchpad.
- **migrationThreshholds** (object) - Thresholds for migration.
  - **quote** (number) - Quote threshold.
- **mintAuthority** (null) - Mint authority, null if not applicable.
- **freezeAuthority** (null) - Freeze authority, null if not applicable.
- **tokenProgram** (string) - The token program used.
- **tokenExtensions** (object) - Token extensions configuration.
- **tradersInvolved** (object) - A map of traders involved.
- **block** (integer) - The block number.
- **timestamp** (integer) - The Unix timestamp.
```

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

### Raydium Launchpad (Bonk) Migration Pool Example

Source: https://pumpapi.io/stream

This example details a pool created through Raydium Launchpad, specifically a Token-USDC pool resulting from a Bonk migration.

```APIDOC
## Transaction Data (Raydium Launchpad Migration)

### Description
Details of a 'sell' transaction within a pool created by Raydium Launchpad, often associated with Bonk migrations.

### Method
POST

### Endpoint
`/api/transactions`

### Parameters
#### Request Body
- **signature** (string) - The transaction signature.
- **txType** (string) - Type of transaction, "sell".
- **poolId** (string) - The unique identifier for the liquidity pool.
- **mint** (string) - The mint address of the token.
- **txSigner** (string) - The address of the transaction signer.
- **tokenAmount** (number) - The amount of tokens traded.
- **solAmount** (number) - The amount of SOL traded.
- **tokensInPool** (number) - The total number of tokens currently in the pool.
- **solInPool** (number) - The total amount of SOL currently in the pool.
- **price** (number) - The price of the token at the time of the transaction.
- **marketCapSol** (number) - The market capitalization in SOL.
- **poolFeeRate** (number) - The fee rate for the pool.
- **pool** (string) - The type of pool, "raydium-cpmm".
- **poolCreatedBy** (string) - Indicates the creator of the pool, "raydium-launchpad".
- **burnedLiquidity** (string) - Percentage of liquidity burned.
- **mintAuthority** (null) - Mint authority, null if not applicable.
- **freezeAuthority** (null) - Freeze authority, null if not applicable.
- **tokenProgram** (string) - The token program used.
- **tokenExtensions** (object) - Token extensions configuration.
- **tradersInvolved** (object) - A map of traders involved.
- **block** (integer) - The block number.
- **timestamp** (integer) - The Unix timestamp.
```

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

### Wrap SOL via PumpAPI

Source: https://pumpapi.io/wrap-sol

Examples for executing the wrapSol action across multiple programming languages.

```python
import aiohttp  
import asyncio  
  
async def wrap_sol():  
    url = "https://api.pumpapi.io"  
    data = {  
        "privateKey": "base58_private_key",  
        "action": "wrapSol",  
        "amount": "0.5",  
        "priorityFee": "0.00002",  
    }  
    async with aiohttp.ClientSession() as session:  
        async with session.post(url, json=data) as response:  
            result = await response.json()  
            print(result)  
  
asyncio.run(wrap_sol())  
```

```javascript
const response = await fetch("https://api.pumpapi.io", {  
  method: "POST",  
  headers: { "Content-Type": "application/json" },  
  body: JSON.stringify({  
    privateKey: "base58_private_key",  
    action: "wrapSol",  
    amount: "0.5",  
    priorityFee: "0.00002",  
  }),  
});  
  
const result = await response.json();  
console.log(result);  
```

```go
package main  
  
import (  
    "bytes"  
    "encoding/json"  
    "fmt"  
    "net/http"  
)  
  
func main() {  
    payload := map[string]string{  
        "privateKey":  "base58_private_key",  
        "action":      "wrapSol",  
        "amount":      "0.5",  
        "priorityFee": "0.00002",  
    }  
  
    body, _ := json.Marshal(payload)  
    resp, err := http.Post("https://api.pumpapi.io", "application/json", bytes.NewBuffer(body))  
    if err != nil {  
        panic(err)  
    }  
    defer resp.Body.Close()  
  
    var result map[string]interface{}  
    json.NewDecoder(resp.Body).Decode(&result)  
    fmt.Println(result)  
}  
```

```rust
use reqwest::Client;  
use serde_json::json;  
  
#[tokio::main]  
async fn main() -> Result<(), Box<dyn std::error::Error>> {  
    let client = Client::new();  
  
    let payload = json!({
        "privateKey": "base58_private_key",  
        "action": "wrapSol",  
        "amount": "0.5",  
        "priorityFee": "0.00002"  
    });  
  
    let res = client  
        .post("https://api.pumpapi.io")  
        .json(&payload)  
        .send()  
        .await?;  
  
    println!("{}", res.text().await?);  
    Ok(())  
}  
```

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

### Connect to PumpAPI WebSocket Stream in JavaScript

Source: https://pumpapi.io/stream

This JavaScript example demonstrates connecting to the WebSocket stream and logging received event data. Ensure you have the 'ws' library installed (`npm i ws`).

```javascript
import WebSocket from 'ws'; // npm i ws  

const ws = new WebSocket('wss://stream.pumpapi.io/');  

ws.on('message', data => {
  const event = JSON.parse(data);
  console.log(event); // { txType: 'create', pool: 'pump', ... }
});

ws.on('error', console.error);
```

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

### Create Token with IPFS Upload (JavaScript)

Source: https://pumpapi.io/create-token-pump-fun

This JavaScript example uses Axios and FormData to upload a logo to IPFS, retrieve the URI, and then create a token. Ensure 'axios', 'fs', and 'form-data' are installed.

```javascript
import axios from 'axios';
import fs from 'fs';
import FormData from 'form-data';

const uriData = {
  name: "PumpApi",
  symbol: "PAPI",
  description: "Fast API for Pump.fun, Raydium, Meteora",
  twitter: "https://x.com/realpumpapi",
  telegram: "https://t.me/YOUR_TG",
  website: "https://pumpapi.io",
  showName: "true",
};

const form = new FormData();
Object.entries(uriData).forEach(([k, v]) => form.append(k, v));
form.append("file", fs.createReadStream("/path/to/coin_logo.webp"), "coin_logo.webp");

const ipfsRes = await axios.post("https://pump.fun/api/ipfs", form, {
  headers: form.getHeaders(),
});
const uri = ipfsRes.data.metadataUri;

const data = {
  privateKey: "base58_private_key",
  action: "create",
  name: "PumpApi",
  symbol: "PAPI",
  uri,
  amount: "0.0001",
  priorityFee: "0.00002001",
};

const response = await axios.post("https://api.pumpapi.io", data);
console.log(response.data);
```

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

### Go WebSocket Relay Server

Source: https://pumpapi.io/FAQ

This Go example demonstrates a WebSocket relay server using the gorilla/websocket library. It manages connected clients and handles upgrades from HTTP requests.

```go
package main

import (
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"
      
    "github.com/gorilla/websocket"
)

var clients = make(map[*websocket.Conn]bool)
var clientsMutex sync.Mutex

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func handleClient(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        return
    }
      
    clientsMutex.Lock()
    clients[conn] = true
    clientsMutex.Unlock()
      
    defer func() {
        clientsMutex.Lock()
        delete(clients, conn)

```

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

### Create Event Example (Raydium Launchpad)

Source: https://pumpapi.io/stream

This JSON object represents a token creation event on the Raydium launchpad. It includes specific launchpad configuration and migration thresholds.

```json
{
  "signature": "3LweLX1CG8qV17EmUztAw6isAZdY8sk2ZmHjiGhC6oY6BvdYQousXDivsSPi2xCf99PDdVAgqDBfyiLniTcmHNqR",
  "txType": "create",
  "poolId": "FADuSqhV5nQqxCapi2PDvKnNnBBqg8DZEEvVGviELXrk",
  "mint": "HnXKZ5GRemRnKUP7wBcmrVcRYkFvQNKq8FtLj3gB1ray",
  "txSigner": "tAg2tgyHmkGTsmq8wBSKsGvUUgoH37cxmCfRUZSXdtB",
  "initialBuy": 151903987.89698,
  "solAmount": 5.0,
  "tokensInPool": 848096012.10302,
  "solInPool": 4.9475,
  "vTokensInBondingCurve": 921121617.699402,
  "vSolInBondingCurve": 34.948352951,
  "price": 3.7941084303598455e-8,
  "marketCapSol": 37.94108430359845,
  "poolFeeRate": 0.0105,
  "name": "arrest",
  "symbol": "aarrest",
  "uri": "https://ipfs.io/ipfs/bafkreih2bzlff4xrkehmezdzirl6ybawtth24niqtjc6qwnordbhydglaq",
  "supply": 1000000000,
  "pool": "raydium-launchpad",
  "platform": "custom",
  "launchpadConfig": "4Bu96XjU84XjPDSpveTVf6LYGCkfW5FK7SNkREWcEfV4",
  "migrationThreshholds": {
    "quote": 85.0
  },
  "mintAuthority": None,
  "freezeAuthority": None,
  "tokenProgram": "spl-token",
  "tokenExtensions": {},
  "tradersInvolved": {
    "tAg2tgyHmkGTsmq8wBSKsGvUUgoH37cxmCfRUZSXdtB": {}
  },
  "decimals": 6,
  "block": 401380627,
  "timestamp": 1771532401666
}
```

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

### Partial Transaction Data Example

Source: https://pumpapi.io/stream

A truncated example of a buy transaction data object.

```json
{
  "signature": "5RKRyZ5E4EjezdhkpnvtPXJoR2hLpHispSrAEWebCAEjheni3D6UrciBWN3becVaaEnZBS69XcdnvvLDRENzUEJv",
  "txType": "buy",
  "poolId": "3DrHmGXh9LVFFxz5yGmgm8jagHijqhXvSQyjhus1etPa",
  "mint": "3DsdCFH1RGfaV1CUSJzbmYQ7vFSsVuEFK1tHRVAiBAGS",
```

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

### Create Event Example (Meteora Launchpad)

Source: https://pumpapi.io/stream

This JSON object represents a token creation event on the Meteora launchpad. It includes details on locked liquidity and migration fee rates.

```json
{
  "signature": "4gDNN8nDdoi84oUW4vb7yKQhsR8kZ5wTiF92REqDiDREGijh7P6VhNeW3QHSozKWA1vCN3GVLjYZfYuetMLjDvtb",
  "txType": "create",
  "poolId": "BDLE4vLJ94mp9tEbTNRhf16vaNJ1cWfUrn5ePfx4EWpv",
  "mint": "CBy1rMkQAHH2Jq8fDsHYTQJBy8S83saHMHM4674TPMuX",
  "txSigner": "6Ed7RBZrKVAq2V67CpNUGJXp4Avnz25KjVzJCq7LaLYz",
  "initialBuy": 984498429.538417,
  "solAmount": 23.0,
  "tokensInPool": 13034155.851211,
  "solInPool": 23.0,
  "price": 1.7741917491987863e-6,
  "marketCapSol": 1774.1917491987863,
  "poolFeeRate": 0.0025,
  "name": "Tesla AI",
  "symbol": "Tesla AI",
  "uri": "https://ipfs.io/ipfs/bafkreigcmxnxj2gteuf6oti2orhztqxp4ngtesaayw2xnmbp6h4pxspgba",
  "supply": 1000000000,
  "pool": "meteora-launchpad",
  "lockedLiquidityAfterMigration": "10%", 
  "poolFeeRateAfterMigration": 0.001,
  "migrationThreshholds": {
    "quote": 30.0
  },
  "launchpadConfig": "E6MQpAxta1AQhsDii3trQrGVooqjkwKQ4LgwZ4SCVgo",
  "mintAuthority": None,
  "freezeAuthority": None,
  "tokenProgram": "spl-token",
  "tokenExtensions": {},
  "tradersInvolved": {
    "6Ed7RBZrKVAq2V67CpNUGJXp4Avnz25KjVzJCq7LaLYz": {}
  },
  "decimals": 6,
  "block": 400339537,
  "timestamp": 1771124275539
}
```

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

### Claim Cashback using JavaScript (axios)

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

This JavaScript example demonstrates claiming cashback using the 'axios' library. Replace 'private_key' with your actual private key. The 'priorityFee' can be adjusted as needed.

```JavaScript
import axios from "axios";

const url = "https://api.pumpapi.io";

const data = {
  privateKey: "private_key",
  action: "claimCashback",
  priorityFee: "0.0000012",
};

axios
  .post(url, data)
  .then((res) => console.log(res.data))
  .catch((err) => console.error(err));

```

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

### Create a token via PumpApi

Source: https://pumpapi.io/create-token-pump-fun

Use these examples to send a POST request to the PumpApi endpoint with the required token metadata and transaction parameters.

```python
import requests  
  
url = "https://api.pumpapi.io"  
  
data = {  
    "privateKey": "base58_private_key",  
    "action": "create",  
    "name": "PumpApi",  
    "symbol": "PAPI",  
    "description": "Fast API for Pump.fun, Raydium, Meteora",  
    "imageURL": "https://pumpapi.io/img/pumpapi_logo.webp",  
    "website": "https://pumpapi.io",  
    "telegram": "https://t.me/YOUR_TG",  
    "x": "https://x.com/realpumpapi",  
    "amount": "0.0001",  
    "denominatedInQuote": "true",  
    "priorityFee": "0.00002001",  
}  
  
response = requests.post(url, json=data)  
print(response.json())  
```

```javascript
import axios from 'axios';  
  
const data = {  
  privateKey: "base58_private_key",  
  action: "create",  
  name: "PumpApi",  
  symbol: "PAPI",  
  description: "Fast API for Pump.fun, Raydium, Meteora",  
  imageURL: "https://pumpapi.io/img/pumpapi_logo.webp",  
  website: "https://pumpapi.io",  
  telegram: "https://t.me/YOUR_TG",  
  x: "https://x.com/realpumpapi",  
  amount: "0.0001",  
  denominatedInQuote: "true",  
  priorityFee: "0.00002001",  
};  
  
axios.post("https://api.pumpapi.io", data)  
  .then(response => console.log(response.data))  
  .catch(error => console.error(error));  
```

```rust
use reqwest::Client;  
use serde_json::json;  
  
#[tokio::main]  
async fn main() -> Result<(), Box<dyn std::error::Error>> {  
    let client = Client::new();  
  
    let res = client  
        .post("https://api.pumpapi.io")  
        .json(&json!({  
            "privateKey": "base58_private_key",  
            "action": "create",  
            "name": "PumpApi",  
            "symbol": "PAPI",  
            "description": "Fast API for Pump.fun, Raydium, Meteora",  
            "imageURL": "https://pumpapi.io/img/pumpapi_logo.webp",  
            "website": "https://pumpapi.io",  
            "telegram": "https://t.me/YOUR_TG",  
            "x": "https://x.com/realpumpapi",  
            "amount": "0.0001",  
            "denominatedInQuote": "true",  
            "priorityFee": "0.00002001"  
        }))  
        .send()  
        .await?  
        .text()  
        .await?;  
  
    println!("{}", res);  
    Ok(())  
}  
```

```go
package main  
  
import (  
    "bytes"  
    "encoding/json"  
    "fmt"  
    "net/http"  
)  
  
func main() {  
    data := map[string]interface{}{  
        "privateKey":         "base58_private_key",  
        "action":             "create",  
        "name":               "PumpApi",  
        "symbol":             "PAPI",  
        "description":        "Fast API for Pump.fun, Raydium, Meteora",  
        "imageURL":           "https://pumpapi.io/img/pumpapi_logo.webp",  
        "website":            "https://pumpapi.io",  
        "telegram":           "https://t.me/YOUR_TG",  
        "x":                  "https://x.com/realpumpapi",  
        "amount":             "0.0001",  
        "denominatedInQuote": "true",  
        "priorityFee":        "0.00002001",  
    }  
  
    jsonData, _ := json.Marshal(data)  
    resp, err := http.Post("https://api.pumpapi.io", "application/json", bytes.NewBuffer(jsonData))  
    if err != nil {  
        panic(err)  
    }  
    defer resp.Body.Close()  
  
    var result map[string]interface{}  
    json.NewDecoder(resp.Body).Decode(&result)  
    fmt.Println(result)  
}  
```

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

### Create Event Example (Pump.Fun)

Source: https://pumpapi.io/stream

This JSON object details a token creation event on Pump.Fun. It includes pool information, initial buy details, and fee rates.

```json
{
  "signature": "58zv6eEs2Y9ARPt9VSdpo6h3A4sg2ijgNftk8vXGvjoHQEiMqgoL6mNnWX9uZ26WS6mtzWuXduf8vuhUwUKJ73Wk",
  "txType": "create",
  "poolId": "EzW8aPTiayL6zNw3rpPTDiPsbPFfNcn7TNB8BstbUYh9",
  "mint": "AvxohnS3SSJRfw4h9u2am5DTRrNv9HY5je7EdqpVSA2i",
  "txSigner": "3dxmSSoSbLpmyZZTJhGP4w9DUPLCrMyyUNpb6eL8e3Rf",
  "initialBuy": 97545454.545454,
  "solAmount": 3.0,
  "tokensInPool": 695554545.454546,
  "solInPool": 3.0,
  "vTokensInBondingCurve": 975454545.454546,
  "vSolInBondingCurve": 33.0,
  "price": 3.383038210624416e-8,
  "marketCapSol": 33.83038210624416,
  "poolFeeRate": 0.0125,
  "name": "CHUD",
  "symbol": "CHUD",
  "uri": "https://metadata.j7tracker.com/metadata/2456cf930d0a4a0e.json",
  "supply": 1000000000,
  "pool": "pump",
  "creatorFeeAddress": "3dxmSSoSbLpmyZZTJhGP4w9DUPLCrMyyUNpb6eL8e3Rf",
  "mayhemMode": False,
  "cashbackEnabled": True,
  "mintAuthority": None,
  "freezeAuthority": None,
  "tokenProgram": "spl-token-2022",
  "tokenExtensions": {
    "metadataPointer": {},
    "tokenMetadata": {}
  },
  "tradersInvolved": {
    "3dxmSSoSbLpmyZZTJhGP4w9DUPLCrMyyUNpb6eL8e3Rf": {}
  },
  "decimals": 6,
  "block": 401114006,
  "timestamp": 1771427621579
}
```

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

### Custom Token-Token Pool Example

Source: https://pumpapi.io/stream

This example illustrates a pool involving two custom tokens, where SOL is not directly involved as a quote currency.

```APIDOC
## Transaction Data (Custom Token-Token Pool)

### Description
Details of a 'sell' transaction in a pool where both the base and quote tokens are custom memecoins.

### Method
POST

### Endpoint
`/api/transactions`

### Parameters
#### Request Body
- **signature** (string) - The transaction signature.
- **txType** (string) - Type of transaction, "sell".
- **poolId** (string) - The unique identifier for the liquidity pool.
- **mint** (string) - The mint address of the base token.
- **quoteMint** (string) - The mint address of the quote token.
- **txSigner** (string) - The address of the transaction signer.
- **tokenAmount** (number) - The amount of base tokens traded.
- **quoteAmount** (number) - The amount of quote tokens traded.
- **tokensInPool** (number) - The total number of base tokens currently in the pool.
- **quoteInPool** (number) - The total amount of quote tokens currently in the pool.
- **price** (number) - The price of the base token in terms of the quote token.
- **marketCapQuote** (number) - The market capitalization based on the quote token.
- **poolFeeRate** (number) - The fee rate for the pool.
- **pool** (string) - The type of pool, "raydium-cpmm".
- **poolCreatedBy** (string) - Indicates the creator of the pool, "custom".
- **burnedLiquidity** (string) - Percentage of liquidity burned.
- **mintAuthority** (string) - The mint authority for the base token.
- **freezeAuthority** (null) - Freeze authority, null if not applicable.
- **tokenProgram** (string) - The token program used.
- **tokenExtensions** (object) - Token extensions configuration.
- **tradersInvolved** (object) - A map of traders involved.
- **block** (integer) - The block number.
- **timestamp** (integer) - The Unix timestamp.
```

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

### Execute Buy and Sell Actions via PumpAPI

Source: https://pumpapi.io/actions

Examples demonstrating how to send a JSON payload containing buy and sell actions to the PumpAPI endpoint.

```python
import requests  
  
url = "https://api.pumpapi.io"  
  
data = {  
    "actions": [  
        {  
            "privateKey": "base58_private_key",  
            "action": "buy",  
            "mint": "token_address",  
            "amount": 0.1,  
            "denominatedInQuote": True,  
            "slippage": 99,  
            "priorityFee": 0.00002,  
        },  
        {  
            "privateKey": "base58_private_key",  
            "action": "sell",  
            "mint": "token_address",  
            "amount": "100%",  
            "denominatedInQuote": True,  
            "slippage": 99,  
            "priorityFee": 0.00002,  
        }  
    ]  
}  
  
response = requests.post(url, json=data)  
print(response.json())
```

```javascript
import axios from 'axios';  
  
const data = {  
  actions: [  
    {  
      privateKey: "base58_private_key",  
      action: "buy",  
      mint: "token_address",  
      amount: 0.1,  
      denominatedInQuote: true,  
      slippage: 99,  
      priorityFee: 0.00002,  
    },  
    {  
      privateKey: "base58_private_key",  
      action: "sell",  
      mint: "token_address",  
      amount: "100%",  
      denominatedInQuote: true,  
      slippage: 99,  
      priorityFee: 0.00002,  
    }  
  ]  
};  
  
axios.post("https://api.pumpapi.io", data)  
  .then(response => console.log(response.data))  
  .catch(error => console.error(error));
```

```rust
use reqwest::Client;  
use serde_json::json;  
  
#[tokio::main]  
async fn main() -> Result<(), Box<dyn std::error::Error>> {  
    let client = Client::new();  
  
    let res = client  
        .post("https://api.pumpapi.io")  
        .json(&json!({  
            "actions": [  
                {  
                    "privateKey": "base58_private_key",  
                    "action": "buy",  
                    "mint": "token_address",  
                    "amount": 0.1,  
                    "denominatedInQuote": true,  
                    "slippage": 99,  
                    "priorityFee": 0.00002  
                },  
                {  
                    "privateKey": "base58_private_key",  
                    "action": "sell",  
                    "mint": "token_address",  
                    "amount": "100%",  
                    "denominatedInQuote": true,  
                    "slippage": 99,  
                    "priorityFee": 0.00002  
                }  
            ]  
        }))  
        .send()  
        .await?  
        .text()  
        .await?;  
  
    println!("{}", res);  
    Ok(())  
}
```

```go
package main  
  
import (  
    "bytes"  
    "encoding/json"  
    "fmt"  
    "net/http"  
)  
  
func main() {  
    data := map[string]interface{}{  
        "actions": []map[string]interface{}{  
            {  
                "privateKey":          "base58_private_key",  
                "action":              "buy",  
                "mint":                "token_address",  
                "amount":              0.1,  
                "denominatedInQuote":  true,  
                "slippage":            99,  
                "priorityFee":         0.00002,  
            },  
            {  
                "privateKey":          "base58_private_key",  
                "action":              "sell",  
                "mint":                "token_address",  
                "amount":              "100%",  
                "denominatedInQuote":  true,  
                "slippage":            99,  
                "priorityFee":         0.00002,  
            },  
        },  
    }  
  
    jsonData, _ := json.Marshal(data)  
    resp, err := http.Post("https://api.pumpapi.io", "application/json", bytes.NewBuffer(jsonData))  
    if err != nil {  
        panic(err)  
    }  
    defer resp.Body.Close()  
  
    var result map[string]interface{}  
    json.NewDecoder(resp.Body).Decode(&result)  
    fmt.Println(result)  
}
```

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

### Create Token with URI (Python)

Source: https://pumpapi.io/create-token-pump-fun

Use this Python snippet to create a token by providing a pre-generated URI. Ensure the 'requests' library is installed.

```python
data = {
    "privateKey": "base58_private_key",
    "action": "create",
    "name": "PumpApi",
    "symbol": "PAPI",
    "uri": uri,
    "amount": "0.0001",
    "priorityFee": "0.00002001",
}

response = requests.post("https://api.pumpapi.io", json=data)
print(response.json())
```

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

### Implement Data Stream Sender with ZeroMQ

Source: https://pumpapi.io/FAQ

These examples demonstrate how to receive data from the PumpAPI WebSocket and republish it locally using ZeroMQ to support multiple downstream consumers.

```python
import asyncio  
import websockets  
import zmq # pip install pyzmq   
import sys  
  
ctx = zmq.Context()  
  
if sys.platform == "win32":  
    sock = ctx.socket(zmq.PUB)  
    sock.bind("tcp://127.0.0.1:8939")  
else:  
    sock = ctx.socket(zmq.PUB)  
    sock.bind("ipc://8939")  # On Linux, IPC is slightly faster than TCP  
  
async def connect_pumpapi_stream():  
    while True:  
        try:  
            async with websockets.connect("wss://stream.pumpapi.io") as ws:  
                while True:  
                    msg = await ws.recv()  
                    sock.send(msg)  
        except Exception as e:  
            print(e)  
            await asyncio.sleep(1)  
  
asyncio.run(connect_pumpapi_stream())
```

```javascript
const WebSocket = require('ws');  
const zmq = require('zeromq');  
  
async function createStreamer() {  
    const sock = new zmq.Publisher();  
      
    if (process.platform === 'win32') {  
        await sock.bind('tcp://127.0.0.1:8939');  
    } else {  
        await sock.bind('ipc://8939'); // On Linux, IPC is slightly faster than TCP  
    }  
      
    async function connectPumpApiStream() {  
        while (true) {  
            try {  
                const ws = new WebSocket('wss://stream.pumpapi.io');  
                  
                ws.on('message', async (msg) => {  
                    await sock.send(msg);  
                });  
                  
                ws.on('error', (error) => {  
                    console.error(error);  
                });  
                  
                ws.on('close', () => {  
                    console.log('Connection closed, reconnecting...');  
                });  
                  
                // Wait for connection to close  
                await new Promise((resolve) => {  
                    ws.on('close', resolve);  
                });  
  
                await new Promise(resolve => setTimeout(resolve, 1000));  
                  
            } catch (error) {  
                console.error(error);  
                await new Promise(resolve => setTimeout(resolve, 1000));  
            }  
        }  
    }  
      
    connectPumpApiStream();  
}  
  
createStreamer();
```

```rust
use tokio_tungstenite::{connect_async, tungstenite::Message};  
use zmq::{Context, Socket, PUB};  
use futures_util::{SinkExt, StreamExt};  
use std::time::Duration;  
  
#[tokio::main]  
async fn main() {  
    let context = Context::new();  
    let sock = context.socket(PUB).unwrap();  
      
    if cfg!(target_os = "windows") {  
        sock.bind("tcp://127.0.0.1:8939").unwrap();  
    } else {  
        sock.bind("ipc://8939").unwrap(); // On Linux, IPC is slightly faster than TCP  
    }  
      
    connect_pumpapi_stream(sock).await;  
}  
  
async fn connect_pumpapi_stream(sock: Socket) {  
    loop {  
        match connect_async("wss://stream.pumpapi.io").await {  
            Ok((ws_stream, _)) => {  
                let (mut write, mut read) = ws_stream.split();  
                  
                while let Some(msg) = read.next().await {  
                    match msg {  
                        Ok(Message::Text(text)) => {  
                            if let Err(e) = sock.send(&text, 0) {
```

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

### Create Token with IPFS Upload (Go)

Source: https://pumpapi.io/create-token-pump-fun

This Go example demonstrates uploading a logo to IPFS and then creating a token using the generated URI. It utilizes the standard library for HTTP requests and multipart form data.

```go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

func main() {
    // Upload to IPFS
    var b bytes.Buffer
    w := multipart.NewWriter(&b)
    for k, v := range map[string]string{
        "name": "PumpApi", "symbol": "PAPI",
        "description": "Fast API for Pump.fun, Raydium, Meteora",
        "twitter": "https://x.com/realpumpapi",
        "telegram": "https://t.me/YOUR_TG",
        "website": "https://pumpapi.io",
        "showName": "true",
    } {
        w.WriteField(k, v)
    }
    f, _ := os.Open("/path/to/coin_logo.webp")
    defer f.Close()
    fw, _ := w.CreateFormFile("file", "coin_logo.webp")
    io.Copy(fw, f)
    w.Close()

    ipfsResp, _ := http.Post("https://pump.fun/api/ipfs", w.FormDataContentType(), &b)
    var ipfsResult map[string]interface{}
    json.NewDecoder(ipfsResp.Body).Decode(&ipfsResult)
    uri := ipfsResult["metadataUri"].(string)

    // Create token
    data := map[string]interface{}{
        "privateKey":  "base58_private_key",
        "action":      "create",
        "name":        "PumpApi",
        "symbol":      "PAPI",
        "uri":         uri,
        "amount":      "0.0001",
        "priorityFee": "0.00002001",
    }

    jsonData, _ := json.Marshal(data)
    resp, err := http.Post("https://api.pumpapi.io", "application/json", bytes.NewBuffer(jsonData))
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result)
}
```

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

### Create Token with IPFS Upload (Rust)

Source: https://pumpapi.io/create-token-pump-fun

This Rust example utilizes reqwest and tokio to upload a logo to IPFS, obtain the URI, and subsequently create a token. Ensure necessary dependencies are added to Cargo.toml.

```rust
use reqwest::{Client, multipart};
use serde_json::json;
use std::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();

    let file_bytes = fs::read("/path/to/coin_logo.webp")?;
    let part = multipart::Part::bytes(file_bytes).file_name("coin_logo.webp");
    let form = multipart::Form::new()
        .text("name", "PumpApi")
        .text("symbol", "PAPI")
        .text("description", "Fast API for Pump.fun, Raydium, Meteora")
        .text("twitter", "https://x.com/realpumpapi")
        .text("telegram", "https://t.me/YOUR_TG")
        .text("website", "https://pumpapi.io")
        .text("showName", "true")
        .part("file", part);

    let ipfs_res: serde_json::Value = client
        .post("https://pump.fun/api/ipfs")
        .multipart(form)
        .send()
        .await?
        .json()
        .await?;

    let uri = ipfs_res["metadataUri"].as_str().unwrap();

    let res = client
        .post("https://api.pumpapi.io")
        .json(&json!({
            "privateKey": "base58_private_key",
            "action": "create",
            "name": "PumpApi",
            "symbol": "PAPI",
            "uri": uri,
            "amount": "0.0001",
            "priorityFee": "0.00002001"
        }))
        .send()
        .await?
        .text()
        .await?;

    println!("{}", res);
    Ok(())
}
```

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

### Create Token and Buy with Multiple Wallets (Python)

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

Use this Python script to create a new token and then have multiple wallets buy it in separate, seemingly unrelated transactions. Ensure you have the 'requests' library installed.

```python
import requests

url = "https://api.pumpapi.io"

data = {
    "jitoTip": 0.00001,
    "transactions": [
        {
            "privateKey": "dev_wallet_private_key",
            "action": "create",
            "name": "PumpApi",
            "symbol": "PAPI",
            "description": "Fast API for Pump.fun, Raydium, Meteora",
            "imageURL": "https://pumpapi.io/img/pumpapi_logo.webp",
            "website": "https://pumpapi.io",
            "telegram": "https://t.me/YOUR_TG",
            "x": "https://x.com/realpumpapi",
            "mintRef": "0", # set a temporary reference for the new token
            "initialTradeAction": "buy",  # dev buy
            "amount": 0.5,
            "denominatedInQuote": True,
            "slippage": 99,
        },
        {
            "privateKey": "wallet_2_private_key",
            "action": "buy",
            "mintRef": "0", # reuse the mintRef we set during create
            "amount": 0.3,
            "denominatedInQuote": True,
            "slippage": 99,
        },
        {
            "privateKey": "wallet_3_private_key",
            "action": "buy",
            "mintRef": "0", # reuse the mintRef we set during create
            "amount": 0.3,
            "denominatedInQuote": True,
            "slippage": 99,
        },
        {
            "privateKey": "wallet_4_private_key",
            "action": "buy",
            "mintRef": "0", # reuse the mintRef we set during create
            "amount": 0.3,
            "denominatedInQuote": True,
            "slippage": 99,
        },
        {
            "privateKey": "wallet_5_private_key",
            "action": "buy",
            "mintRef": "0", # reuse the mintRef we set during create
            "amount": 0.3,
            "denominatedInQuote": True,
            "slippage": 99,
        }
    ]
}

response = requests.post(url, json=data)
print(response.json())
```
Tokens:
Raw