Create Token | Raydium API

Launch tokens on Raydium Launchpad in a single request. It works just like Create Token on Pump.fun. Every token is launched on a config — it sets the fees and can limit the launch params. By default, StonkFun's config is used.

Endpoint

POST https://api.pumpapi.io

Parameters

Parameter	Required	Description
`pool`	Yes	`"raydium-launchpad"`
`name`	Yes	Token name
`symbol`	Yes	Token ticker symbol
`launchpadConfig`	No	Config address. Default: StonkFun.xyz config. Take another one from any Raydium Launchpad event in the Data Stream or create your own
`quoteMint`	No	Quote token. Default: SOL
`amount`	No	Dev buy on launch, in the quote token

Everything else — imageURL, description, website, telegram, x, uri, mintRef, Jito Bundles, Actions and local transactions — works the same as on Pump.fun.

Curve Settings (optional)

Parameter	Default	Description
`supply`	`1000000000`	Total supply.
`migrationThreshold`	`85` SOL	How much the curve raises before the token moves to a Raydium CPMM pool
`tokensSoldBeforeMigration`	`793100000`	Number of tokens sold on the curve (not percent). The rest goes into the pool. Default: 79.31% of supply
`tokenProgram`	`"spl-token"`	Or `"spl-token-2022"`
`transferFee`	None	Fee on every token transfer, up to 5%. Example: `"3%"`. Needs `"spl-token-2022"`. The config owner collects it, not you
`creatorFeeAddress`	your wallet	Wallet that earns creator fees

A config can have rules. Params you skip are filled in to match them. If a param breaks a rule, the error tells you what to change.

Basic Example

Python
JavaScript
Rust
Go

import requests

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

data = {
    "privateKey": "base58_private_key", # or use "apiKey": "your_api_key" instead — generate one at pumpapi.io/trade-api (🔑 spoiler)
    "action": "create",
    "pool": "raydium-launchpad",
    "name": "PumpApi",
    "symbol": "PAPI",
    "imageURL": "https://pumpapi.io/img/pumpapi_logo.webp",
    "amount": 0.1, # dev buy in SOL
}

response = requests.post(url, json=data)
print(response.json())

import axios from 'axios';

const data = {
  privateKey: "base58_private_key", // or use "apiKey": "your_api_key" instead — generate one at pumpapi.io/trade-api (🔑 spoiler)
  action: "create",
  pool: "raydium-launchpad",
  name: "PumpApi",
  symbol: "PAPI",
  imageURL: "https://pumpapi.io/img/pumpapi_logo.webp",
  amount: 0.1, // dev buy in SOL
};

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", // or use "apiKey": "your_api_key" instead — generate one at pumpapi.io/trade-api (🔑 spoiler)
            "action": "create",
            "pool": "raydium-launchpad",
            "name": "PumpApi",
            "symbol": "PAPI",
            "imageURL": "https://pumpapi.io/img/pumpapi_logo.webp",
            "amount": 0.1, // dev buy in SOL
        }))
        .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", // or use "apiKey": "your_api_key" instead — generate one at pumpapi.io/trade-api (🔑 spoiler)
        "action":     "create",
        "pool":       "raydium-launchpad",
        "name":       "PumpApi",
        "symbol":     "PAPI",
        "imageURL":   "https://pumpapi.io/img/pumpapi_logo.webp",
        "amount":     0.1, // dev buy in SOL
    }

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

The address of the new token comes back in createdMints.

Create Your Own Config

Want your own fees? Create a config and launch tokens on it:

{
  "privateKey": "base58_private_key", // or use "apiKey": "your_api_key" instead
  "action": "createConfig",
  "pool": "raydium-launchpad",
  "name": "MyPad"
}

Send it the same way as the Basic Example. The address of the new config comes back in createdLaunchpadConfigs. Pass it as launchpadConfig when you create tokens.

Parameter	Default	Description
`pool`	—	`"raydium-launchpad"` (required)
`name`, `website`, `imageURL`	""	Your launchpad name, site and logo. Explorers show them
`poolFeeRate`	`0.01` (1%)	Trading fee on the curve for you and the token creator. Raydium adds its own 0.25% on top
`creatorFeeShare`	`"50%"`	Part of `poolFeeRate` paid to the token creator. Creator part: up to 0.5%. Your part: up to 5%
`poolFeeRateAfterMigration`	`0.0025` (0.25%)	Trading fee in the pool after migration. One of: `0.0025`, `0.003`, `0.005`, `0.01`, `0.015`, `0.02`, `0.025`, `0.04`
`burnedLiquidityAfterMigration`	`"0%"`	Part of the pool liquidity burned at migration. The rest is locked for you: it earns pool fees but can't be withdrawn
`platformFeeAddress`	your wallet	Wallet that gets your fees, your locked liquidity and transfer fees

One wallet can have only one Raydium config — this is a Raydium rule. Creating it costs about 0.01 SOL of rent.

Lock Launch Params (optional)

By default, anyone can launch any token on your config. To use the same params for every token, add any of these to createConfig: quoteMint, supply, tokensSoldBeforeMigration, migrationThreshold, tokenProgram, transferFee.

Value	Means
`"85"`	exactly 85
`"50-200"`	50 to 200
`"50-"`	50 or more
`"-200"`	200 or less

{
  "privateKey": "base58_private_key",
  "action": "createConfig",
  "pool": "raydium-launchpad",
  "name": "MyPad",
  "supply": 1000000000,
  "migrationThreshold": "50-200"
}

Tokens launched on your config get these values automatically. When you lock any of them, your config accepts only one quote token (SOL by default). If the params break Raydium limits, you get an error and nothing is sent.

Config and Token in One Transaction

Set launchpadConfigRef on createConfig and use it on create instead of launchpadConfig — just like mintRef. The token gets the config's quote token and locked params automatically. Works in Jito Bundles too.

{
  "actions": [
    {
      "privateKey": "base58_private_key",
      "action": "createConfig",
      "pool": "raydium-launchpad",
      "launchpadConfigRef": "0", // temporary reference for the new config
      "name": "MyPad"
    },
    {
      "privateKey": "base58_private_key",
      "action": "create",
      "pool": "raydium-launchpad",
      "launchpadConfigRef": "0", // reuse it instead of launchpadConfig
      "name": "PumpApi",
      "symbol": "PAPI",
      "imageURL": "https://pumpapi.io/img/pumpapi_logo.webp",
      "amount": 0.1
    }
  ]
}

Example Response

For createConfig:

{
  "signature": "4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi5nwVydAxEyehawMzuCcnvzH8QRL7C5z9DRnm6HeVKn4pW",
  "err": "",
  "timestamp": 1790154524625,
  "createdLaunchpadConfigs": ["2Sx3FU41MbasE6AfvDJCoNpbuGsAVMwbNbnUNE8aDr18"]
}

Need help? Join our Telegram group.

Endpoint​

Parameters​

Curve Settings (optional)​

Basic Example​

Create Your Own Config​

Lock Launch Params (optional)​

Config and Token in One Transaction​

Example Response​