Create Token

Create tokens on Pump.fun directly through our API — in a single request. This is an extension of the Trade API: everything that works there works here too.

Endpoint

POST https://api.pumpapi.io

Parameters

Parameter	Required	Description
`name`	Yes	Token name
`symbol`	Yes	Token ticker symbol
`imageURL`	No	Token image URL. Without it, Pump.fun won't display your token — only bots will be able to trade it. You can host images on prnt.sc, imgur.com, or imgbb.com, or simply copy an image URL from Google Images.
`description`	No	Token description
`website`	No	Project website URL
`telegram`	No	Telegram channel/group link
`x`	No	X (Twitter) profile link
`uri`	No	Custom metadata URI. If provided, `imageURL`, `description`, `website`, `telegram`, and `x` are ignored
`mayhemMode`	No	Default: `false`
`cashbackToTradersEnabled`	No	Default: `false`. If `true`, trading fees are earned by traders, not you
`mintPrivateKey`	No	Custom mint address key. By default we generate tokens with the `pump` ending — you don't need to set this
`amount`	No	Amount of SOL to buy as dev on launch

Basic Example

Python
JavaScript
Rust
Go

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

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

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

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

Multi-Wallet Launch with Actions

You can use Actions to apply advanced strategies — for example, buying from multiple wallets in a single transaction, or changing the txSigner to avoid some copy-traders.

{
  "privateKey": "base58_fee_payer_key",
  "actions": [
    {
      "privateKey": "dev_wallet_key",
      "action": "create",
      "name": "PumpApi",
      "symbol": "PAPI",
      "imageURL": "https://pumpapi.io/img/pumpapi_logo.webp",
      "amount": 0.1
    },
    {
      "privateKey": "wallet_b_key",
      "action": "buy",
      "mint": "token_address",
      "amount": 0.05,
      "denominatedInQuote": true,
      "slippage": 99
    },
    {
      "privateKey": "wallet_c_key",
      "action": "buy",
      "mint": "token_address",
      "amount": 0.05,
      "denominatedInQuote": true,
      "slippage": 99
    }
  ]
}

Local Transactions

Local (unsigned) transactions are supported too — just send publicKey instead of privateKey to receive an unsigned transaction, sign it on your side, and broadcast it yourself. See the Trade API page for local transaction code examples.

Custom Metadata URI

For experts

This step is entirely optional. By default, we host your token metadata on our server so you can create a token with a single request.

If you want to use the standard Pump.fun method, you can upload your icon and metadata to IPFS yourself, then pass the resulting URI as "uri" when creating the token. When uri is set, the imageURL, description, telegram, and x fields are ignored.

Show IPFS upload example

Python
JavaScript
Rust
Go

import requests

# Define token metadata
uri_data = {
    "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"
}

# Load your image
# Windows:
# with open("C:\\Users\\Admin\\Pictures\\coin_logo.webp", "rb") as f:
#     file_content = f.read()

# Linux / macOS:
with open("/path/to/coin_logo.webp", "rb") as f:
    file_content = f.read()

coin_logo = {"file": ("coin_logo.webp", file_content, "image/webp")}

# Upload to IPFS via Pump.fun
response = requests.post("https://pump.fun/api/ipfs", data=uri_data, files=coin_logo)
uri = response.json()["metadataUri"]

# Use the URI when creating your token
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())

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

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

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

Need help? Join our Telegram group.

Endpoint​

Parameters​

Basic Example​

Multi-Wallet Launch with Actions​

Local Transactions​

Custom Metadata URI​