We Benchmarked Every Major Solana Trading API. LaserSell is 2-5x Faster.
LaserSell builds Solana swap transactions 2-5x faster than PumpFun SDK, PumpPortal, and Jupiter. Open-source benchmarks you can verify yourself.
In volatile memecoin markets, milliseconds matter. The difference between 75ms and 300ms? Missing your exit while the price crashes.
We benchmarked LaserSell against every major way to build Solana swap transactions: PumpFun SDK, PumpPortal, and Jupiter's Metis API. The results are open-source and reproducible.
TL;DR: LaserSell is 2-5x faster than alternatives.
Results
Buy Transaction Build (0.01 SOL, 20% slippage, 20 samples)
| Method | Median (ms) | Avg (ms) | Min (ms) | Max (ms) | vs LaserSell |
|---|---|---|---|---|---|
| LaserSell API | 71.16 | 71.21 | 62.77 | 81.30 | — |
| PumpPortal API | 141.44 | 151.08 | 120.96 | 246.40 | 2.0x slower |
| Jupiter Metis API | 168.11 | 179.83 | 153.17 | 370.01 | 2.4x slower |
| PumpFun SDK | 364.92 | 790.94 | 278.57 | 4,570.26 | 5.1x slower |
Sell Transaction Build (1,000,000 tokens, 20% slippage, 20 samples)
| Method | Median (ms) | Avg (ms) | Min (ms) | Max (ms) | vs LaserSell |
|---|---|---|---|---|---|
| LaserSell API | 71.72 | 74.77 | 65.13 | 108.67 | — |
| PumpPortal API | 120.59 | 152.08 | 111.91 | 554.96 | 1.7x slower |
| Jupiter Metis API | 174.92 | 181.73 | 155.88 | 222.54 | 2.4x slower |
| PumpFun SDK | 317.28 | 541.00 | 277.65 | 2,029.10 | 4.4x slower |
LaserSell consistently delivers sub-80ms median transaction builds across both buy and sell operations. More importantly, the variance is tight: an ~19-44ms spread between min and max, compared to 125ms+ (and often 2,000ms+) for other methods.
Predictable latency matters as much as raw speed.
What These Numbers Mean
For Traders
- 71ms vs 365ms can determine whether you catch a 10x pump or miss it
- Tighter variance (~19ms spread) means fewer "unexpectedly slow" transactions
- In high-volatility markets, every millisecond counts
For Developers
- One API call instead of 5+ RPC roundtrips
- No quote → swap two-step flow
- No waiting for on-chain state lookups
- Consistent performance under load
What We Tested
These benchmarks measure transaction build latency: the time from API request to receiving a signed, ready-to-send transaction.
What we tested:
- ✅ Transaction construction time
- ✅ API response time
- ✅ Serialization overhead
What we didn't test:
- ❌ Network confirmation time (depends on Solana network, not the API)
- ❌ Transaction success rates (would require actual sends)
How Each Method Works
LaserSell API:
Single HTTP request → server builds transaction → returns base64-encoded transaction.
PumpFun SDK:
5+ RPC calls to fetch bonding curve state, token accounts, recent blockhash → local transaction assembly.
PumpPortal API:
Single HTTP request → server builds transaction → returns serialized transaction.
Jupiter Metis API:
Two sequential HTTP requests: quote endpoint → swap endpoint with quote ID.
The key difference: roundtrip count and server-side optimization.
Methodology
Benchmarks ran on a MacBook Pro with consistent network conditions:
- 1 warmup iteration (discarded)
- 20 timed iterations per method
- 2 second delay between runs (avoid rate limiting)
process.hrtime.bigint()for nanosecond-precision timing- Same Pump.fun token across all tests
- 20% slippage tolerance (standard for volatile memecoins)
- PumpFun SDK used Shyft RPC endpoint (all tests used the exact same RPC and token to eliminate variables)
Run It Yourself
The entire benchmark suite is open-source. Clone it, run it on your hardware, and verify these results yourself:
git clone https://github.com/lasersell/benchmarks.git
cd benchmarks
cp .env.example .env # add your API keys
Each benchmark lives in its own directory. To run the buy transaction build benchmark:
cd buy-tx-build
npm install && npm run build
npm run bench
To run the sell transaction build benchmark:
cd sell-tx-build
npm install && npm run build
npm run bench
Both benchmarks accept CLI overrides for mint, wallet, amount, slippage, and iteration count. See the repo README for the full list of options.
We encourage you to run these benchmarks and share your results. If you think our methodology can be improved, open an issue and we'll update the benchmarks accordingly.
Want to see different scenarios? The benchmark suite accepts custom parameters. Test with different token amounts, slippage settings, or RPC endpoints. All results are reproducible.
Why This Matters
Speed Compounds
In a typical trading session, you might build 10-50 transactions. If each transaction takes 365ms instead of 71ms to build, you're losing 294ms × 50 = 14.7 seconds of cumulative latency.
In memecoin markets where prices can move 20-50% in seconds, this adds up fast.
Reliability Under Load
The tight variance in LaserSell's results means consistent performance even during network congestion. Other methods show 5-10x higher variance, indicating they're more sensitive to external factors.
Get Started with LaserSell
If you're building Solana trading infrastructure and speed matters:
- Read the docs — Get started with the API in 5 minutes
- Try it free — Free tier available, no credit card required
- Join Discord — Talk to the team and other builders
- View source — Open-source client, MIT licensed
Built for developers who care about performance.
Questions about the benchmarks? Open an issue or reach us on X @lasersellhq.