Pump.fun Token Creation
You can create tokens via the pump.fun API.
There is no additional fee for token creation. The standard trading fee is applied to the initial dev buy.
Examples below:
Lightning Transaction Examples:
- Python
- JavaScript
import requests
import json
from solders.keypair import Keypair
def send_create_tx():
# Generate a random keypair for token
mint_keypair = Keypair()
# Define token metadata
form_data = {
'name': 'PPTest',
'symbol': 'TEST',
'description': 'This is an example token created via PumpPortal.fun',
'twitter': 'https://x.com/a1lon9/status/1812970586420994083',
'telegram': 'https://x.com/a1lon9/status/1812970586420994083',
'website': 'https://pumpportal.fun',
'showName': 'true'
}
# Read the image file
with open('./example.png', 'rb') as f:
file_content = f.read()
files = {
'file': ('example.png', file_content, 'image/png')
}
# Create IPFS metadata storage
metadata_response = requests.post("https://pump.fun/api/ipfs", data=form_data, files=files)
metadata_response_json = metadata_response.json()
# Token metadata
token_metadata = {
'name': form_data['name'],
'symbol': form_data['symbol'],
'uri': metadata_response_json['metadataUri']
}
# Send the create transaction
response = requests.post(
"https://pumpportal.fun/api/trade?api-key=your-api-key",
headers={'Content-Type': 'application/json'},
data=json.dumps({
'action': 'create',
'tokenMetadata': token_metadata,
'mint': str(mint_keypair),
'denominatedInSol': 'true',
'amount': 1, # Dev buy of 1 SOL
'slippage': 10,
'priorityFee': 0.0005,
'pool': 'pump'
})
)
if response.status_code == 200: # successfully generated transaction
data = response.json()
print(f"Transaction: https://solscan.io/tx/{data['signature']}")
else:
print(response.reason) # log error
send_create_tx()
async function sendCreateTx(){
// Generate a random keypair for token
const mintKeypair = Keypair.generate();
// Define token metadata
const formData = new FormData();
formData.append("file", await fs.openAsBlob("./example.png")), // Image file
formData.append("name", "PPTest"),
formData.append("symbol", "TEST"),
formData.append("description", "This is an example token created via PumpPortal.fun"),
formData.append("twitter", "https://x.com/a1lon9/status/1812970586420994083"),
formData.append("telegram", "https://x.com/a1lon9/status/1812970586420994083"),
formData.append("website", "https://pumpportal.fun"),
formData.append("showName", "true");
// Create IPFS metadata storage
const metadataResponse = await fetch("https://pump.fun/api/ipfs", {
method: "POST",
body: formData,
});
const metadataResponseJSON = await metadataResponse.json();
// Send the create transaction
const response = await fetch(`https://pumpportal.fun/api/trade?api-key=your-api-key`, {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify({
"action": "create",
"tokenMetadata": {
name: metadataResponseJSON.metadata.name,
symbol: metadataResponseJSON.metadata.symbol,
uri: metadataResponseJSON.metadataUri
},
"mint": bs58.encode(mintKeypair.secretKey),
"denominatedInSol": "true",
"amount": 1, // Dev buy of 1 SOL
"slippage": 10,
"priorityFee": 0.0005,
"pool": "pump"
})
});
if(response.status === 200){ // successfully generated transaction
const data = await response.json();
console.log("Transaction: https://solscan.io/tx/" + data.signature);
} else {
console.log(response.statusText); // log error
}
}
sendCreateTx();
Local Transaction Examples:
- Python
- JavaScript
import requests
import json
from solders.keypair import Keypair
from solders.transaction import VersionedTransaction
from solders.keypair import Keypair
from solders.commitment_config import CommitmentLevel
from solders.rpc.requests import SendVersionedTransaction
from solders.rpc.config import RpcSendTransactionConfig
def send_local_create_tx():
signer_keypair = Keypair.from_base58_string('your-base58-private-key')
# Generate a random keypair for token
mint_keypair = Keypair()
# Define token metadata
form_data = {
'name': 'PPTest',
'symbol': 'TEST',
'description': 'This is an example token created via PumpPortal.fun',
'twitter': 'https://x.com/a1lon9/status/1812970586420994083',
'telegram': 'https://x.com/a1lon9/status/1812970586420994083',
'website': 'https://pumpportal.fun',
'showName': 'true'
}
# Read the image file
with open('./example.png', 'rb') as f:
file_content = f.read()
files = {
'file': ('example.png', file_content, 'image/png')
}
# Create IPFS metadata storage
metadata_response = requests.post("https://pump.fun/api/ipfs", data=form_data, files=files)
metadata_response_json = metadata_response.json()
# Token metadata
token_metadata = {
'name': form_data['name'],
'symbol': form_data['symbol'],
'uri': metadata_response_json['metadataUri']
}
# Generate the create transaction
response = requests.post(
"https://pumpportal.fun/api/trade-local",
headers={'Content-Type': 'application/json'},
data=json.dumps({
'publicKey': str(signer_keypair.pubkey()),
'action': 'create',
'tokenMetadata': token_metadata,
'mint': str(mint_keypair.pubkey()),
'denominatedInSol': 'true',
'amount': 1, # Dev buy of 1 SOL
'slippage': 10,
'priorityFee': 0.0005,
'pool': 'pump'
})
)
tx = VersionedTransaction(VersionedTransaction.from_bytes(response.content).message, [mint_keypair, signer_keypair])
commitment = CommitmentLevel.Confirmed
config = RpcSendTransactionConfig(preflight_commitment=commitment)
txPayload = SendVersionedTransaction(tx, config)
response = requests.post(
url="Your RPC endpoint - Eg: https://api.mainnet-beta.solana.com/",
headers={"Content-Type": "application/json"},
data=SendVersionedTransaction(tx, config).to_json()
)
txSignature = response.json()['result']
print(f'Transaction: https://solscan.io/tx/{txSignature}')
send_local_create_tx()
import { VersionedTransaction, Connection, Keypair } from '@solana/web3.js';
import bs58 from "bs58";
const RPC_ENDPOINT = "Your RPC Endpoint";
const web3Connection = new Connection(
RPC_ENDPOINT,
'confirmed',
);
async function sendLocalCreateTx(){
const signerKeyPair = Keypair.fromSecretKey(bs58.decode("your-wallet-private-key"));
// Generate a random keypair for token
const mintKeypair = Keypair.generate();
// Define token metadata
const formData = new FormData();
formData.append("file", await fs.openAsBlob("./example.png")), // Image file
formData.append("name", "PPTest"),
formData.append("symbol", "TEST"),
formData.append("description", "This is an example token created via PumpPortal.fun"),
formData.append("twitter", "https://x.com/a1lon9/status/1812970586420994083"),
formData.append("telegram", "https://x.com/a1lon9/status/1812970586420994083"),
formData.append("website", "https://pumpportal.fun"),
formData.append("showName", "true");
// Create IPFS metadata storage
const metadataResponse = await fetch("https://pump.fun/api/ipfs", {
method: "POST",
body: formData,
});
const metadataResponseJSON = await metadataResponse.json();
// Get the create transaction
const response = await fetch(`https://pumpportal.fun/api/trade-local`, {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify({
"publicKey": 'your-wallet-public-key',
"action": "create",
"tokenMetadata": {
name: metadataResponseJSON.metadata.name,
symbol: metadataResponseJSON.metadata.symbol,
uri: metadataResponseJSON.metadataUri
},
"mint": mintKeypair.publicKey.toBase58(),
"denominatedInSol": "true",
"amount": 1, // dev buy of 1 SOL
"slippage": 10,
"priorityFee": 0.0005,
"pool": "pump"
})
});
if(response.status === 200){ // successfully generated transaction
const data = await response.arrayBuffer();
const tx = VersionedTransaction.deserialize(new Uint8Array(data));
tx.sign([mintKeypair, signerKeyPair]);
const signature = await web3Connection.sendTransaction(tx)
console.log("Transaction: https://solscan.io/tx/" + signature);
} else {
console.log(response.statusText); // log error
}
}
sendLocalCreateTx();
Jito Bundle Examples:
- Python
- JavaScript
import requests
import base58
from solders.transaction import VersionedTransaction
from solders.keypair import Keypair
def send_create_tx_bundle():
signerKeypairs = [
Keypair.from_base58_string("Wallet A base 58 private key here"),
Keypair.from_base58_string("Wallet B base 58 private key here")
# use up to 5 wallets
]
# Generate a random keypair for token
mint_keypair = Keypair()
# Define token metadata
form_data = {
'name': 'PPTest',
'symbol': 'TEST',
'description': 'This is an example token created via PumpPortal.fun',
'twitter': 'https://x.com/a1lon9/status/1812970586420994083',
'telegram': 'https://x.com/a1lon9/status/1812970586420994083',
'website': 'https://pumpportal.fun',
'showName': 'true'
}
# Read the image file
with open('./example.png', 'rb') as f:
file_content = f.read()
files = {
'file': ('example.png', file_content, 'image/png')
}
# Create IPFS metadata storage
metadata_response = requests.post("https://pump.fun/api/ipfs", data=form_data, files=files)
metadata_response_json = metadata_response.json()
# Token metadata
token_metadata = {
'name': form_data['name'],
'symbol': form_data['symbol'],
'uri': metadata_response_json['metadataUri']
}
bundledTransactionArgs = [
{
'publicKey': str(signerKeypairs[0].pubkey()),
'action': 'create',
'tokenMetadata': token_metadata,
'mint': str(mint_keypair.pubkey()),
'denominatedInSol': 'false',
'amount': 1000000, # Dev buy of 1000000 tokens
'slippage': 10,
'priorityFee': 0.0005,
'pool': 'pump'
},
{
"publicKey": str(signerKeypairs[1].pubkey()),
"action": "buy", # "buy", "sell", or "create"
"mint": str(mint_keypair.pubkey()),
"denominatedInSol": "false",
"amount": 1000000,
"slippage": 50,
"priorityFee": 0.0001, # priority fee after first tx is ignored
"pool": "pump"
}
# use up to 5 transactions
]
# Generate the bundled transactions
response = requests.post(
"https://pumpportal.fun/api/trade-local",
headers={"Content-Type": "application/json"},
json=bundledTransactionArgs
)
if response.status_code != 200:
print("Failed to generate transactions.")
print(response.reason)
else:
encodedTransactions = response.json()
encodedSignedTransactions = []
txSignatures = []
for index, encodedTransaction in enumerate(encodedTransactions):
if bundledTransactionArgs[index]["action"] == "create":
signedTx = VersionedTransaction(VersionedTransaction.from_bytes(base58.b58decode(encodedTransaction)).message, [mint_keypair, signerKeypairs[index]])
else:
signedTx = VersionedTransaction(VersionedTransaction.from_bytes(base58.b58decode(encodedTransaction)).message, [signerKeypairs[index]])
encodedSignedTransactions.append(base58.b58encode(bytes(signedTx)).decode())
txSignatures.append(str(signedTx.signatures[0]))
jito_response = requests.post(
"https://mainnet.block-engine.jito.wtf/api/v1/bundles",
headers={"Content-Type": "application/json"},
json={
"jsonrpc": "2.0",
"id": 1,
"method": "sendBundle",
"params": [
encodedSignedTransactions
]
}
)
for i, signature in enumerate(txSignatures):
print(f'Transaction {i}: https://solscan.io/tx/{signature}')
send_create_tx_bundle()
async function sendLocalCreateBundle(){
const signerKeyPairs = [
Keypair.fromSecretKey(bs58.decode("Wallet A base 58 private key here")),
Keypair.fromSecretKey(bs58.decode("Wallet B base 58 private key here")),
// use up to 5 wallets
];
const mintKeypair = Keypair.generate(); // generates a random keypair for token
let tokenMetadata = {
name: "TEST",
symbol: "AAA",
description: "This is an example token created via PumpPortal.fun",
twitter: "https://x.com/a1lon9/status/1812970586420994083",
telegram: "https://x.com/a1lon9/status/1812970586420994083",
website: "https://pumpportal.fun",
file: await fs.openAsBlob("./new-moon-face.png"),
};
let formData = new FormData();
formData.append("file", tokenMetadata.file),
formData.append("name", tokenMetadata.name),
formData.append("symbol", tokenMetadata.symbol),
formData.append("description", tokenMetadata.description),
formData.append("twitter", tokenMetadata.twitter || ""),
formData.append("telegram", tokenMetadata.telegram || ""),
formData.append("website", tokenMetadata.website || ""),
formData.append("showName", "true");
let metadataResponse = await fetch("https://pump.fun/api/ipfs", {
method: "POST",
body: formData,
});
let metadataResponseJSON = await metadataResponse.json();
const bundledTxArgs = [
{
"publicKey": signerKeyPairs[0].publicKey.toBase58(),
"action": "create",
"tokenMetadata": {name: tokenMetadata.name, symbol: tokenMetadata.symbol, uri: metadataResponseJSON.metadataUri},
"mint": mintKeypair.publicKey.toBase58(),
"denominatedInSol": "false",
"amount": 10000000,
"slippage": 10,
"priorityFee": 0.0001, // priority fee on the first tx is used for jito tip
"pool": "pump"
},
{
publicKey: signerKeyPairs[1].publicKey.toBase58(),
"action": "buy",
"mint": mintKeypair.publicKey.toBase58(),
"denominatedInSol": "false",
"amount": 10000000,
"slippage": 10,
"priorityFee": 0.00005, // priority fee after first tx is ignored
"pool": "pump"
},
// use up to 5 transactions
];
const response = await fetch(`https://pumpportal.fun/api/trade-local`, {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(bundledTxArgs)
});
if(response.status === 200){ // successfully generated transactions
const transactions = await response.json();
let encodedSignedTransactions = [];
let signatures = [];
for(let i = 0; i < bundledTxArgs.length; i++){
const tx = VersionedTransaction.deserialize(new Uint8Array(bs58.decode(transactions[i])));
if(bundledTxArgs[i].action === "create"){ // creation transaction needs to be signed by mint and creator keypairs
tx.sign([mintKeypair, signerKeyPairs[i]])
} else {
tx.sign([signerKeyPairs[i]]);
}
encodedSignedTransactions.push(bs58.encode(tx.serialize()));
signatures.push(bs58.encode(tx.signatures[0]));
}
try{
const jitoResponse = await fetch(`https://mainnet.block-engine.jito.wtf/api/v1/bundles`, {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify({
"jsonrpc": "2.0",
"id": 1,
"method": "sendBundle",
"params": [
encodedSignedTransactions
]
})
});
console.log(jitoResponse);
} catch(e){
console.error(e.message);
}
for(let i = 0; i < signatures.length; i++){
console.log(`Transaction ${i}: https://solscan.io/tx/${signatures[i]}`);
}
} else {
console.log(response.statusText); // log error
}
}
sendLocalCreateBundle();
Bonk Token Creation Examples:
- Python
- JavaScript
import requests
import json
from solders.keypair import Keypair
def send_create_tx_bonk():
# Generate a random keypair for token
mint_keypair = Keypair()
print("Token CA generated. Token address: ")
print(mint_keypair.pubkey())
name = "PumpPortalTest"
symbol = "PORTAL"
# Read the image file
with open('./example.png', 'rb') as f:
file_content = f.read()
files = {
'file': ('example.png', file_content, 'image/png')
}
# Create IPFS metadata storage
img_response = requests.post("https://nft-storage.letsbonk22.workers.dev/upload/img", files=files)
img_uri = img_response.text
metadata_response = requests.post(
"https://nft-storage.letsbonk22.workers.dev/upload/meta",
headers={'Content-Type': 'application/json'},
data=json.dumps({
'createdOn': "https://bonk.fun",
'description': "Test token for PumpPortal.fun",
'image': img_uri,
'name': name,
'symbol': symbol,
'website': "https://pumpportal.fun"
})
)
metadata_uri = metadata_response.text
# Token metadata
token_metadata = {
'name': name,
'symbol': symbol,
'uri': metadata_uri
}
# Send the create transaction
response = requests.post(
"https://pumpportal.fun/api/trade?api-key=your-api-key-here",
headers={'Content-Type': 'application/json'},
data=json.dumps({
'action': 'create',
'tokenMetadata': token_metadata,
'mint': str(mint_keypair),
'denominatedInSol': 'true',
'amount': 1, # Dev buy of 1 SOL
'slippage': 10,
'priorityFee': 0.00005,
'pool': 'bonk'
})
)
if response.status_code == 200: # successfully generated transaction
data = response.json()
print(f"Transaction: https://solscan.io/tx/{data['signature']}")
else:
print(response.reason) # log error
send_create_tx_bonk()
async function sendCreateTxBonk() {
// Generate a random keypair for token
const mintKeypair = Keypair.generate();
const name = "PumpPortalTest";
const symbol = "PORTAL";
const formData = new FormData();
formData.append("image", await fs.openAsBlob("./example.png")) // Image file
// Create IPFS metadata storage
const imgResponse = await fetch("https://nft-storage.letsbonk22.workers.dev/upload/img", {
method: "POST",
body: formData,
});
let imgUri = await imgResponse.text()
console.log(imgUri);
const metadataResponse = await fetch("https://nft-storage.letsbonk22.workers.dev/upload/meta", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
createdOn: "https://bonk.fun",
description: "Test token for PumpPortal.fun",
image: imgUri,
name: name,
symbol: symbol,
website: "https://pumpportal.fun"
}),
})
let metadataUri = await metadataResponse.text();
console.log(metadataUri);
// Get the create transaction
const response = await fetch(
`https://pumpportal.fun/api/trade?api-key=${pumpPortalAPIKey}`,
{
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
action: "create",
tokenMetadata: {
name: name,
symbol: symbol,
uri: metadataUri,
},
mint: bs58.encode(mintKeypair.secretKey), // contract address of the token you want to trade
denominatedInSol: "true", // "true" if amount is amount of SOL, "false" if amount is number of tokens
amount: 0.5, // amount of SOL or tokens
slippage: 5, // percent slippage allowed
priorityFee: 0.00005,
pool: "bonk"
}),
}
);
if (response.status === 200) {
// successfully generated transaction
const data = await response.json();
console.log("Transaction: https://solscan.io/tx/" + data.signature);
} else {
console.log(response.statusText); // log error
}
}
sendCreateTxBonk();