How to build a Solana arbitrage bot that actually lands bundles in 2026

A market that has fully professionalized

Arbitrage now drives a structural share of Solana's onchain DEX activity. Independent research on SOL-stablecoin pools through late 2025 concluded that a majority of volume on passive AMMs is searcher flow trading against stale quotes, not organic user demand. Jito's bundle marketplace has crossed three billion bundles processed lifetime, with 3.75 million SOL paid out as tips to validators and stakers. The Jito-Solana client now runs under roughly 92–93% of staked SOL—which means almost every block in mid-2026 is being assembled by a validator who accepts paid bundles by default.

That's the market. It's professionalized. Sub-millisecond pipelines, dedicated bare-metal, dynamic tip auctions running thousands of times a day, multi-relay submission as standard practice. A bot polling a public RPC every 200ms is not in this game—it's renting compute on top of it.

The pipeline, reframed as latency budgets

A profitable arb bot is not a script. It's a pipeline with five hard latency budgets, and missing any one of them means the opportunity belongs to someone else.

The cascade is what kills you. A slow RPC contaminates path search, late path search produces a stale transaction, a stale transaction loses the bundle race against operators who built every layer on validator-grade infra.

Stack: language and DEX coverage

The Rust-versus-TypeScript debate is mostly settled. TypeScript with @solana/web3.js and jito-ts works for prototypes and for strategies where you're not racing the top of the searcher pack. For anything competing on sub-slot inclusion, you're writing Rust against solana-sdk and jito-searcher-client—not as a fashion choice, but because v8 GC pauses are physics you can't tune away.

Venues worth covering in mid-2026:

• Raydium—CPMM and CLMM, still the deepest passive book on most SOL pairs.
• Orca Whirlpools—concentrated liquidity, dominant on SOL/USDC and stable pairs.
• Meteora DLMM—dynamic-fee pools, tight Jupiter integration, heavy memecoin flow.
• Phoenix—onchain order book, useful for cross-venue and CEX–DEX legs.
• PumpSwap—relevant since Pump pulled graduated tokens out of Raydium's flow; long-tail liquidity sits here.

Jupiter's self-hosted aggregator binary, run as a sidecar on loopback, removes the need to maintain bespoke routing across thirty-plus venues. Treat it as a quote oracle, not a runtime dependency.

Start narrow. One pair, two venues, prove the loop runs in budget. Expanding coverage is cheap once the latency profile is healthy. Trying to debug latency on a fifteen-DEX bot is not.

The data feed is the whole game

The single most common failure mode in production arb stacks is reading state from RPC poll or WebSocket subscription. Both are too slow for 2026 conditions. Yellowstone Geyser gRPC streams account writes directly out of the validator's accounts DB the moment they commit—you're reading from the same surface the validator itself sees when it builds the next block.

A minimum working .env:

RPC_HTTP=https://your-dedicated-endpoint
RPC_WS=wss://your-dedicated-endpoint
GEYSER_GRPC=grpc://your-yellowstone-endpoint:10000
GEYSER_TOKEN=...
JITO_BLOCK_ENGINE=ny.mainnet.block-engine.jito.wtf
COMMITMENT=processed

Three decisions that matter:

• Run on processed commitment. confirmed and finalized add latency for safety properties that atomic reverts already give you for free.
• Subscribe to specific pool accounts with server-side filters, not full program subscriptions. Your event loop should not be drowning in writes you'll never act on.
• Co-locate the bot with the Geyser endpoint. Cross-region adds 30–80ms of wire latency that no amount of code can recover.

const subscribeRequest = {
  accounts: {
    raydium_clmm_sol_usdc: {
      account: ['POOL_ACCOUNT_PUBKEY'],
      owner: [],
      filters: []
    }
  },
  commitment: CommitmentLevel.PROCESSED
};

The submission path is no longer just Jito

Through 2024 the playbook was simple: bundle through Jito or lose. In mid-2026 the picture is more layered. Astralane and QuickNode's Lil-JIT have grown into credible alternative paths, each with distinct latency and reliability characteristics. Serious operators now treat transaction submission as a routing problem, not a single endpoint, and abstract their pipeline behind a strategy interface that can fan out across all three with raw RPC submission as a degraded fallback.

JITO_ENABLED=true
JITO_TIP_BASE_LAMPORTS=300000
ASTRALANE_ENABLED=true
LILJIT_ENABLED=true
PRIORITY_FEE_TIER=dynamic
MAX_TIP_LAMPORTS=5000000

Tip economics in mid-2026 are unforgiving. Searchers chasing the same opportunity routinely surrender 50–70% of expected profit to the validator to win the slot. Pay too little and your bundle is skipped; pay too much and the strategy stops paying for itself. Hardcoded tips do not survive contemporary block conditions—dynamic tipping calibrated against rolling block telemetry is the only setting that holds up across congestion regimes. Fan out submissions to multiple block engine regions (NY, Frankfurt, Tokyo) on every send; the next slot leader could be near any of them, and parallel relays cost almost nothing relative to a missed bundle.

Risk controls and the on-chain assertion

SLIPPAGE_BPS=10
MIN_PROFIT_BPS=10
ONCHAIN_MIN_PROFIT_BPS=5
MAX_ACCOUNTS=25
COMPUTE_UNIT_LIMIT=900000

Two hard rules that separate bots that bleed from bots that don't:

• Run simulateTransaction before submission on any meaningfully tipped opportunity. A failed simulation is free. A failed bundle that paid 0.005 SOL in tip is not.
• Encode an onchain profit assertion in the program path so the transaction reverts itself if realized output drops below threshold. Pool state can shift between detection and execution. The chain is the only honest source of truth.

What to instrument before going to mainnet

If those metrics aren't green on devnet against simulated flow, they will not become green on mainnet under real competition.

Where the edge actually lives in 2026

The honest read on the current market: vanilla two-leg arb on the most liquid SOL pairs is saturated. The teams winning that bracket run on bare-metal EPYC boxes colocated with high-stake validators, stream Geyser at sub-5ms, route in parallel across Jito, Astralane, and Lil-JIT, and tune tips off live block telemetry. They are not faster because their idea was clever. They are faster because the rack is in the right building.

If competing in that bracket isn't on the table, the realistic edge moved to thinner liquidity—fresh launchpad pools, niche memecoin pairs on PumpSwap and Meteora DLMM, three-leg routes through unpopular intermediates. Long-tail arb has worse dollar throughput per opportunity, but competition is two orders of magnitude lighter.

In our experience operating Solana infrastructure for searcher teams and DeFi protocols, when bot logic is sound and results still don't materialize, the failure is almost never the strategy. It's the data feed, the submission path, or both. The latency profile of a properly tuned stack—bare-metal compute, Yellowstone gRPC, multi-relay submission, SWQoS forwarding—is in a different distribution from anything you can rent off a generic cloud endpoint.

Talk to Dysnix about the layer underneath

Dedicated bare-metal nodes, Yellowstone Geyser endpoints, native Jito and Astralane integration, SWQoS-enabled transaction forwarding, dynamic tip telemetry—none of this is strategy work, but it is exactly where most underperforming arbitrage operations are quietly losing the race.

Dysnix builds and operates that layer for searchers, market makers, and DeFi protocols on Solana. If the bot logic checks out and the P&L still isn't where it should be, the bottleneck is almost always upstream of your code.

Contact us—we'll show you exactly where the milliseconds are going.