Building a Solana trading bot usually means fighting infrastructure instead of writing strategy. The standard @solana/web3.js stack forces you to manage RPC connections, fetch quotes, build instructions, and handle priority fees. A basic single-wallet script takes over 150 lines of boilerplate with a sluggish 250 to 500ms latency. Scaling to multiple wallets only multiplies the complexity.
We are taking a different approach. Using a single API, we will build a multi-wallet trading bot in under 50 lines of Python. One HTTP request handles the entire execution layer: transaction building, signing, multi-wallet coordination, and priority fees. This drops typical network latency down to 25 to 50ms. No Solana SDK. No RPC setup. Just one dependency: requests.
Important distinction: The API is your execution engine, but you build the brain. A single POST request executes your trade, but you define the trigger (whether that is a WebSocket price feed, a gRPC stream, or a Telegram command). You decide when to fire, and the API does the heavy lifting.
Step 1: Setup your API Key in 30 Seconds
Head to app.launchpad.trade, sign in (Google, Discord, GitHub, or email magic link), and generate your API key.
Test it:
curl -X GET https://api.launchpad.trade/health \
-H "X-API-Key: YOUR_API_KEY"
onst response = await fetch('https://api.launchpad.trade/health', {
headers: { 'X-API-Key': 'YOUR_API_KEY' }
});
const data = await response.json();
import requests
response = requests.get(
'https://api.launchpad.trade/health',
headers={'X-API-Key': 'YOUR_API_KEY'}
)
use reqwest::header::HeaderMap;
let mut headers = HeaderMap::new();
headers.insert("X-API-Key", "YOUR_API_KEY".parse().unwrap());
let client = reqwest::Client::new();
let res = client
.get("https://api.launchpad.trade/health")
.headers(headers)
.send()
.await?;
req, _ := http.NewRequest("GET", "https://api.launchpad.trade/health", nil)
req.Header.Set("X-API-Key", "YOUR_API_KEY")
client := &http.Client{}
resp, _ := client.Do(req)
The region field shows which server is handling your requests. The API runs dedicated infrastructure across the US, Europe, and Asia, routing you to the closest one automatically.
Pro tip: Run your scripts from a VPS in the same region for the lowest latency. See the Best Practices guide for setup details.
Step 2: Create & Fund a Wallet Fleet
Instead of generating keypairs locally and funding wallets one by one, two API calls handle everything.
Five wallets, returned instantly. The API generates Solana keypairs server-side and returns them once, it does not keep a copy. If you lose the private keys, there is no recovery. Save them before doing anything else.
The method parameter controls how SOL is routed between wallets. Here we're using DIRECT, the fastest, simplest option, but the API offers several routing methods with different levels of on-chain separation: standard transfers, privacy-protocol routing for cryptographic wallet isolation, and CEX-based distribution that makes funding look like regular exchange withdrawals. The right method depends on whether you need your wallets to appear independent from each other. Full comparison in Transfer Methods
This ensures your first trade executes at full speed. Without it, the first swap handles setup automatically, but with extra latency. Full details on wallet initialization.
Scale note: The API supports up to 100 wallets per creation call and 100 wallets per trade. Some users manage fleets of 500+ wallets for market making or coordinated strategies. The infrastructure scales, you decide how many wallets your strategy needs.
Step 3: Execute Your First Multi-Wallet Buy
One API call, five wallets buying the same token simultaneously, all targeting the same block.
These are independent transactions (35 to 42ms each) where each wallet is the sole signer. There are no bundle flags, making the buys look entirely organic. Coordinating this manually would take 100+ lines of concurrent code.
Latency Breakdown:networkLatency (35 to 42ms) is the time from the API receiving your request to broadcasting it to validators. confirmLatency (typically 400 to 800ms) includes Solana network confirmation. Standard RPCs take 250 to 500ms just for the send.
Amount Modes: Choose from FIXED (same amount), RANGE (randomized amounts), TOTAL (budget split evenly), or CUSTOM (specific amounts per wallet).
Priority Fees: Use FAST (0.00015 SOL) for standard trades, ULTRA (0.0015 SOL) for time-critical block-0 acquisitions, or a CUSTOM value.
Platform Attribution: Apply an optional platformTag to display logos like Photon, Axiom, BullX, or GMGN on tracking platforms. Full Platform Attribution docs
Step 4: Sell & Take Profit
The sell endpoint adds a type field, sell by percentage or exact token count.
Full cycle done: create → fund → buy → sell → withdraw. Six API calls total.
Step 5: The Complete Bot in 50 Lines
Your 50-line script loads the wallets, buys the token, waits for a trigger, and sells. The input() function acts as a placeholder for your strategy trigger. In production, replace this manual trigger with:
Sniper bot: A gRPC stream watching for new Pump.fun creations.
Social trading bot: A Telegram bot listening for /buy and /sell commands.
Price-based automation: A WebSocket price feed from Birdeye or Jupiter.
Copy trading: A gRPC stream monitoring a whale's wallet.
import requests, json
API = "https://api.launchpad.trade"
H = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}
# Load your wallets (saved from Step 2)
with open("wallets.json") as f:
KEYS = [w["privateKey"] for w in json.load(f)]
TOKEN = input("Token address to buy: ")
# 1. Buy across all wallets with varied random amounts
buy = requests.post(f"{API}/trading/instant/buy", headers=H, json={
"tokenAddress": TOKEN,
"privateKeys": KEYS,
"amount": {"mode": "RANGE", "min": 0.03, "max": 0.08},
"priorityFee": {"mode": "FAST"}
}).json()
for tx in buy["data"]["transactions"]:
print(f" {tx['wallet'][:8]}... {tx['status']} (net:{tx['networkLatency']}ms, confirm:{tx['confirmLatency']}ms)")
print(f"Total spent: {buy['data']['summary']['totalSolSpent']} SOL")
# 2. Wait for YOUR trigger — this is where your strategy lives
# Replace this input() with any signal source:
# - WebSocket/gRPC price feed → sell when price hits target
# - Telegram bot command → sell when user sends /sell
# - Twitter listener → sell when a specific account posts
# - Scheduled timer → sell after X minutes
input("\nPress Enter to sell all positions...")
# 3. Sell 100% from all wallets
sell = requests.post(f"{API}/trading/instant/sell", headers=H, json={
"tokenAddress": TOKEN,
"privateKeys": KEYS,
"amount": {"type": "PERCENT", "mode": "FIXED", "value": 100},
"priorityFee": {"mode": "ULTRA"}
}).json()
print(f"Sold! Received {sell['data']['summary']['totalSolReceived']} SOL")
# 4. Withdraw profits to main wallet
requests.post(f"{API}/funding/withdraw", headers=H, json={
"sourcePrivateKeys": KEYS,
"destinationPublicKey": "YOUR_MAIN_WALLET_ADDRESS",
"amount": {"mode": "ALL"},
"method": "DIRECT"
})
print("Profits withdrawn ✓")
Beyond Trading: The Full Toolkit
Beyond Trading: The Full Toolkit
The API provides over 40 endpoints across 6 categories for the complete token lifecycle:
Token Launch: Deploy tokens on Pump.fun, Bonk, Bags, Raydium, and Meteora. Configure name, ticker, image, socials, and dev buy in one transaction. Manage post-launch fee shares, claim fees, and revoke authority. Create Token documentation
Trading Modes: Use Instant (parallel), Delayed (staggered), or Bundle (atomic) execution. Automated tools handle liquidity contribution and holder diversification. Trading documentation
Utilities: Query balances, burn tokens, check system health, and close empty accounts to reclaim rent (which adds up fast across 50+ wallets). Utilities documentation
The trading workflow above uses 4 of the API's 6 categories. Here's the complete picture, over 40 endpoints covering the entire Solana token lifecycle.
What you can build
What You Can Build
Chat Bots: Execute Telegram/Discord trades with 40ms confirmation.
Automated Launchers: Connect AI and social feeds to automatically deploy tokens.
Market Making: Manage hundreds of wallets with advanced privacy routing.
Custom Dashboards: Build internal tools that outpace public platforms.
Pricing
Pricing: 1% on successful swaps. Failed transactions, wallet operations, reads, and utilities are completely free. Pricing details
Frequently Asked Questions
What is the fastest Solana trading API?
Launchpad.trade delivers 25-50ms typical network latency (send time) on dedicated infrastructure across the US, Europe, and Asia, compared to ~250ms on standard RPCs. Every API response includes both a networkLatency field (time to build, sign, and broadcast your transaction) and a confirmLatency field (total time including Solana network confirmation), so you can verify exactly what the API controls versus what the network adds.
Do I need to run my own RPC node to trade on Solana programmatically?
No. The API abstracts away all RPC and node management. You send a single HTTP request with what you want to do (buy, sell, create token), and the infrastructure handles transaction construction, signing, priority fees, and submission. You don't need @solana/web3.js, Jupiter, or any Solana SDK.
Can I trade with multiple wallets simultaneously on Solana?
Yes. The API supports up to 100 wallets per request natively. All wallets sign their own transactions independently and target the same block, no bundle flags, no on-chain grouping. Each transaction appears fully organic.
Is the Launchpad.trade API non-custodial?
Yes. The API never stores private keys. Keys are sent with each request to sign the transaction in real time. Key management is entirely your responsibility.
What launchpads and DEXs does the API support?
The API is natively compatible with Pump.fun, Bonk, Bags, Raydium, Meteora, and other major Solana launchpads and liquidity pools, with new platforms added regularly. You don't need to reverse-engineer protocols or maintain separate integrations, the API handles compatibility.
Start Building
You can build a working multi-wallet bot in under 50 lines of Python without SDKs or RPC configurations. With over 40 endpoints across 6 categories, the infrastructure is ready for token launches, privacy routing, and automated trading.
Launchpad.Trade provides non-custodial software infrastructure for professional Solana operations. Cryptocurrency trading involves substantial risk of loss. No guaranteed outcomes. Users are solely responsible for compliance with all applicable laws and regulations in their jurisdiction. See our Terms of Use.
Build a Solana Sniper Bot in 2026: Developer Tutorial
Learn how to build a high-speed Solana sniper bot in 2026. Bypass complex RPC setups and achieve sub-50ms latency with our programmatic trading API tutorial.
Best Trojan Bot Alternative: Solana Trading APIs Explained
Looking for a reliable Trojan bot alternative? Discover how upgrading to a programmatic Solana API offers 25ms latency and ultimate multi-wallet control.
.jpg)
.jpeg)
.jpg)
.png)
