I Sniped a Solana Token in 400ms — Here's the Full Tech Stack

When Solana's new token $XYZ launched last week, I managed to snipe it in just 400ms after liquidity was added. Here's the complete technical breakdown of how I built this sniper bot using Jito MEV bundles, Jupiter routing, and Helius RPC - with all the code and hard-earned lessons.

The Architecture Breakdown

My sniper workflow looks like this:

1. Monitoring: Watch for new liquidity pairs via Helius webhooks
2. Simulation: Pre-simulate trades using Jupiter's API
3. Execution: Submit MEV bundle via Jito
4. Confirmation: Verify success with custom RPC setup

Total time from detection to on-chain confirmation: 400ms average.

1. Liquidity Detection with Helius

Helius provides superior new pair detection compared to traditional methods. Their webhooks fire within 50-100ms of pool creation.

Here's my Python listener:

from flask import Flask, request
import json
import asyncio

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
async def webhook():
    data = json.loads(request.data)

    if data['event_type'] == 'NEW_LIQUIDITY_POOL':
        new_pool = data['payload']

        # Filter for specific token criteria
        if (new_pool['token_a'] == 'XYZ' or new_pool['token_b'] == 'XYZ') \
           and new_pool['lp_fee_bps'] < 100:  # Reasonable fees

            print(f"New XYZ pool detected: {new_pool['address']}")
            asyncio.create_task(process_pool(new_pool))

    return '', 200

Key advantages of Helius here:

• 98.7% uptime in my testing
• Average 80ms faster than public RPC endpoints
• Built-in event filtering reduces false positives

2. Jupiter Routing Optimization

Jupiter's API provides the most efficient routes, but we need to pre-cache routes to save precious milliseconds:

import requests

JUPITER_API = "https://quote-api.jup.ag/v6"

async def get_optimal_route(input_mint, output_mint, amount):
    params = {
        'inputMint': input_mint,
        'outputMint': output_mint,
        'amount': amount,
        'slippageBps': 50,  # 0.5%
        'onlyDirectRoutes': False
    }

    try:
        response = requests.get(f"{JUPITER_API}/quote", params=params)
        return response.json()['data'][0]  # Take top route
    except Exception as e:
        print(f"Jupiter routing failed: {e}")
        return None

Pro tip: I maintain a local cache of recent routes to shave off another 20-30ms on repeat swaps.

3. Jito MEV Bundle Execution

This is where the magic happens. Jito bundles let you frontrun regular transactions by paying priority fees.

Here's my bundle submission code:

from solders.pubkey import Pubkey
from jito_searcher_client import searcher_client, Bundle

async def submit_bundle(transactions, tip_lamports=50000):
    client = searcher_client.SearcherClient("https://mainnet.jito.wtf")

    bundle = Bundle(
        transactions=transactions,
        header=searcher_client.BundleHeader(
            priority_fee=tip_lamports,
            use_ledger_confirmed_slot=True
        )
    )

    try:
        await client.send_bundle(bundle)
        print(f"Bundle submitted with tip {tip_lamports} lamports")
    except Exception as e:
        print(f"Bundle failed: {e}")

Critical parameters I've optimized:

• Tip amount: 50,000 lamports (~$0.15) gives 95% success rate
• Bundle size: 3-5 transactions max for fastest inclusion
• Timing: Submit within same leader slot (400ms window)

4. Custom RPC Configuration

Using a standard public RPC would add 200-300ms of latency. My setup:

RPC_CONFIG = {
    "endpoint": "https://mainnet.helius-rpc.com/?api-key=YOUR_KEY",
    "timeout": 100,  # ms
    "commitment": "confirmed",
    "ws_url": "wss://mainnet.helius-rpc.com/?api-key=YOUR_KEY",
    "batch_size": 5,  # For parallel requests
    "retries": 1      # More adds latency
}

This configuration achieves:

• 120ms average response time
• 99.2% success rate
• 40% faster than default public endpoints

The Complete Sniper Flow

Putting it all together:

async def snipe_new_pool(pool_info):
    # Step 1: Get route
    route = await get_optimal_route(
        "So11111111111111111111111111111111111111112",  # SOL
        pool_info['token_a'] if pool_info['token_b'] == 'XYZ' else pool_info['token_b'],
        0.1 * 10**9  # 0.1 SOL
    )

    # Step 2: Build transaction
    swap_tx = await build_swap_transaction(route)

    # Step 3: Simulate
    sim_result = await simulate_transaction(swap_tx)
    if not sim_result['success']:
        return

    # Step 4: Submit bundle
    await submit_bundle([swap_tx], tip_lamports=75000)

Hard-Earned Lessons

1. Timing is everything: My first version had 800ms latency - too slow. Every 100ms matters.

2. Error handling will save you: 30% of my early failures were from not handling RPC timeouts properly.

3. MEV is competitive: During peak times, I had to increase tips to 150,000 lamports to get included.

4. Simulation is crucial: Without proper simulation, I burned $500 in failed transactions early on.

5. Monitor gas prices: SOL price fluctuations directly impact your profitability.

Results and Metrics

After 2 weeks of running:

• Success rate: 72% (started at 35%)
• Average latency: 400ms (best was 380ms)
• Profit per snipe: $50-$200 (after fees)
• Failed transactions: 8% (mostly from competition)

Conclusion

Building a competitive Solana sniper requires optimizing every layer of the stack - from RPC selection to MEV bundle construction. The difference between a 400ms and 800ms snipe can be the difference between profit and loss. While the core concepts are straightforward, the real challenge lies in the micro-optimizations and handling Solana's unique performance characteristics.

---

🚀 Try It Yourself & Get Airdropped

If you want to test this without building from scratch, use @ApolloSniper_Bot — the fastest non-custodial Solana sniper. When the bot hits $10M trading volume, the new $APOLLOSNIPER token will be minted and a massive 20% of the token supply will be airdropped to wallets that traded through the bot, based on their volume!

Join the revolution today.