How to Beat Snipers and Land Transactions Faster on Solana

Practical strategies for outpacing competing bots on Solana — from leader proximity routing to TPU direct submission and timing by the leader schedule.

  • March 5, 2026
  • Infrastructure
  • AllenHark Team
A quiet stack of pagesAn abstract drawing of light on the page's dark ground. A neat stack of thin, solid pages, the top one lit, with faint streams of light drifting toward it from the left.A quiet stack of pagesAn abstract drawing of light on the page's dark ground. A neat stack of thin, solid pages, the top one lit, with faint streams of light drifting toward it from the left.

You see the opportunity. You sign the transaction. You submit it. And someone else's transaction lands first.

If you're running any kind of latency-sensitive strategy on Solana — sniping new token launches, arbitraging DEX price discrepancies, or liquidating undercollateralized positions — you're in a speed competition. The difference between landing first and landing second is often measured in single-digit milliseconds.

Here's how to win that race.

Why You're Losing

Before optimizing, understand where time is being spent:

1. Your Sender Is Far from the Leader

This is the #1 reason traders lose races. Solana's leader validator changes every 4 slots (~1.6 seconds). If you're sending through a fixed endpoint and the current leader is in a different continent, you're adding 80–200ms of pure network latency. Your competitor, submitting from a closer location, wins every time.

2. Gossip Network Propagation

If your transaction goes through sendTransaction on a standard RPC, it enters the gossip network — a mesh of nodes that propagate transactions gradually. This adds 200ms–2s compared to direct delivery.

3. Single Sender Lock-In

Using one sender (say, Jito) means you're fast when Jito has a good path to the leader, and slow when it doesn't. The leader changes constantly — no single sender is fastest for every slot.

4. No Real-Time Intelligence

If you don't know the current leader's location, you can't optimize your submission path. You're submitting blind and hoping for the best.

Strategy 1: Get Close to the Leader

The single biggest speed improvement comes from geographic proximity to the current leader. Light travels at a fixed speed — a transaction from Chicago to a Chicago-based validator takes ~1ms. The same transaction from Europe takes ~80ms.

What to do: Run infrastructure in multiple regions, or use a relay service with multi-region workers.

AllenHark Relay runs in four regions: Frankfurt, Amsterdam, New York and Tokyo. Its QUIC endpoints work from any location, and every transaction goes out through all of its stake-weighted endpoints at once, whichever region you send to.

Strategy 2: Use the Fastest Protocol

Not all protocols are equal:

ProtocolOverheadBest For
QUICLowestPrimary — stream multiplexing, 0-RTT reconnect
gRPCLowStructured data, bidirectional streaming
WebSocketMediumPersistent connections, browser clients
HTTPHighestFallback, simplest integration

QUIC gives you the lowest latency because it combines connection establishment and data transfer. With 0-RTT reconnection, subsequent submissions skip the handshake entirely.

AllenHark Relay takes QUIC, WebSocket and HTTPS. Its docs recommend QUIC, with HTTPS as the simplest integration.

Strategy 3: Submit to the TPU Directly

For the absolute fastest delivery, bypass everything and send your serialized transaction directly to the leader's TPU via UDP. AllenHark Relay does this for every transaction it accepts: alongside its other channels, it sends over QUIC and UDP straight to the current and upcoming leaders' TPU.

Raw UDP gives you no confirmation receipt — you'll need your own monitoring pipeline (gRPC subscription, WebSocket signatureSubscribe, or polling).

When to use: Arbitrage opportunities where you're sending many transactions and only need one to land. The speed advantage outweighs the lack of confirmation.

Strategy 4: Time Submissions by the Leader Schedule

Don't submit blindly. The leader schedule is public: the RPC methods getLeaderSchedule and getSlotLeaders tell you which validator leads each upcoming slot, and getClusterNodes gives its TPU address.

This lets you time your submissions for when you have a good path to the leader, rather than submitting on every slot and paying for every attempt.

Strategy 5: Send Through More Than One Path

Instead of picking one sender and sticking with it, send through more than one path at once.

Different senders have different advantages:

  • Some have better peering with certain validator operators
  • Some have faster paths to specific data centers
  • Some perform better under congestion

AllenHark Relay sends every transaction through five channels at once: stake-weighted QUIC, QUIC and UDP to the leaders, an RPC fan-out, and the Jito Block Engine with other relayers. You are not tied to any one path.

Strategy 6: Reduce Your Own Latency

Infrastructure matters on your end too:

  1. Co-locate with your relay — If your bot runs in the same region as the relay endpoint it sends to, the hop between them is minimal (co-location)
  2. Pre-sign transactions — Have transactions ready to submit the moment you detect an opportunity
  3. Use persistent connections — QUIC and WebSocket maintain open connections, avoiding reconnection overhead
  4. Parallelize detection and submission — Don't wait for detection to complete before preparing the transaction

Strategy 7: Use Bundles for Atomic Execution

When you need multiple transactions to execute together (e.g., a swap followed by a transfer), use atomic bundles. AllenHark Relay takes Jito bundles of up to five transactions over QUIC, WebSocket or HTTPS: all of them execute, in order, or none do. A bundle carries a Jito tip as well as the relay tip (bundle docs).

Bundles prevent partial execution that could leave you in an unfavorable state.

Putting It All Together

The winning stack in 2026:

  1. Detect opportunity via shreds or gRPC stream (fastest possible state updates)
  2. Pre-sign transaction while detecting (parallel processing)
  3. Check the leader schedule — who leads the next slots, and where?
  4. Submit via TPU direct for maximum speed
  5. Monitor confirmation via separate gRPC subscription

Get Started

Create an API key in the Relay tab of the console, add a tip inside your transaction and send it.