Copy trading & automation

Top 7 Solana MEV Bot Tools (2026)

Compare SolanaMevBot, Jito, bloXroute, Helius, Triton, QuickNode and Chainstack on bundles, data feeds, transaction routing, pricing and risks.

Tools at a glance

7 listed tools
  1. SolanaMevBot
  2. Jito Block Engine and Bundles
  3. bloXroute Trader API
  4. Helius
  5. Triton
  6. QuickNode Lil’ JIT
  7. Chainstack

Solana MEV tools help traders identify arbitrage opportunities, monitor changing liquidity, and submit transactions through specialized execution infrastructure. SolanaMevBot provides an automated arbitrage workflow, while Jito, bloXroute, Helius, Triton, QuickNode, and Chainstack supply different combinations of routing, streaming, and transaction services that require trading logic. This comparison is based on each provider's official documentation and published features, checked in November 2026; we have not tested the tools hands-on.

Which one to pick

  • Automated Solana arbitrage: SolanaMevBot, for market selection and on-chain route execution.
  • Atomic multi-transaction strategies: Jito Block Engine and Bundles, for ordered execution through the Block Engine or direct BAM ingest for approved users.
  • Trading API and configurable routing: bloXroute Trader API, for transaction submission alongside swap and fee endpoints.
  • RPC, streaming, and transaction delivery: Helius, for combining market monitoring with Sender infrastructure.
  • Raw transaction data: Triton, for validator shred feeds delivered to your own processing system.
  • Existing infrastructure: QuickNode Lil’ JIT for managed bundle access, or Chainstack for Geyser subscriptions and Warp routing.

Compare Solana MEV bot execution, data access, and costs

ToolBest forExecution and data accessPrice
SolanaMevBotReady-made Solana arbitrage automationOpportunity feeds, on-chain routing, configurable markets and transaction senders10% of profit above the transaction's minimum-profit floor; network fees and tips extra
Jito Block Engine and BundlesAtomic execution of dependent transactionsUp to five ordered transactions; auction-based bundle submissionMinimum 1,000 lamports per bundle tip
bloXroute Trader APITrading APIs with adjustable transaction propagationJupiter swaps, fee data, protected routing, multiple API interfacesIntroductory and paid tiers; minimum 0.001 SOL tip per submitted transaction
HeliusUnified Solana data streaming and transaction deliveryRPC, LaserStream, Sender, optional MEV protectionDeveloper $49/month; Business $499/month; separate sending tips
TritonRaw validator data for custom processingRPC, streaming APIs, raw shred delivery$0.08/GB plus $10/million RPC calls; shreds $900–$1,500/month/IP
QuickNode Lil’ JITManaged Jito bundle access through QuickNodeBundle submission, simulation, landing checks, tip informationFrom $89/month plus underlying service and on-chain costs
ChainstackManaged Solana subscriptions and transaction routingYellowstone Geyser streams; Warp submission through bloXrouteGrowth $49/month; Geyser $49/month; Warp $0.15/send

The tools

SolanaMevBot

Automated on-chain arbitrage

Its bot selects candidate markets using an observed-arbitrage feed, builds transactions, and invokes a Solana program that checks current pool state before choosing a route and trade size. The V10 instruction supports direct swaps and bridge-token routes across documented DEX integrations, including Raydium, Meteora, Orca, and Pump.fun Swap. Traders configure settlement in SOL or USDC, market filters, an RPC endpoint, and transaction senders. The provider charges 10% of successful trade profit above the applicable transaction profit floor; without that floor, the fee applies to the full profit. Hosting, tips, and network charges remain separate.

Choose it when you want packaged arbitrage logic instead of maintaining your own opportunity detector.

Watch out for dependence on the provider's historical opportunity feed and on-chain executor. Its no-failure setting can also permit fee-paying transactions without a completed trade.

Jito Block Engine and Bundles

Atomic transaction execution

PriceMinimum 1,000 lamports per bundle tip

Jito supplies infrastructure for searchers who already know which transactions they want to execute. Its Block Engine accepts signed bundles containing a maximum of five transactions, processes them sequentially, and submits selected combinations to compatible Jito-Solana leaders. When executed as a bundle, all constituent transactions must succeed together. Searchers bid for inclusion using SOL tips, with a documented minimum of 1,000 lamports. The API provides submission and status methods, and its tip data can inform bidding decisions.

Choose it when several dependent trading operations must execute in one ordered sequence.

Watch out for auction competition, leader compatibility, and bundle expiry. Receiving a bundle identifier does not establish that any transaction landed.

bloXroute Trader API

Trading endpoints and submission controls

bloXroute combines Solana trading functions with specialized transaction propagation. Its Trader API includes Jupiter quote and swap endpoints, priority-fee information, bundle-tip streams, transaction submission, and status-related methods. Builders can use HTTP, gRPC, WebSocket, and other documented interfaces. Submission configurations include options for staked RPC paths, front-running protection, and revert-oriented routing. The provider offers an introductory account alongside paid service tiers, with account credits controlling request capacity. Its published routing configurations specify a minimum 0.001 SOL tip for the documented modes, separate from applicable priority fees.

Choose it when your bot benefits from integrated transaction-building endpoints and configurable propagation.

Watch out for credit consumption across different API methods and protection settings that restrict which routes receive transactions.

Helius

Solana data and sending infrastructure

PriceDeveloper $49/month; Business $499/month; separate sending tips

Helius provides Solana RPC access, LaserStream subscriptions, and transaction delivery through Sender. Builders can read liquidity accounts, consume streaming updates, and submit signed transactions without maintaining a validator node. Standard RPC sending consumes plan credits; Sender consumes no credits and requires a SOL tip; its SWQOS-only option documents a 0.000005 SOL minimum tip, compared with 0.001 SOL for Sender Max. Helius also documents optional MEV Protect routing, activated per request to avoid validators associated with sandwich activity. The Developer subscription costs $49 monthly, includes 10 million credits, and lists 50 RPC requests per second. Business costs $499 monthly and adds mainnet LaserStream gRPC, 100 million credits, and 200 RPC requests per second.

Choose it when you need one provider for account reads, event subscriptions, and transaction delivery.

Watch out for plan-dependent gRPC availability, credit quotas, and the separate economic cost of sending through tipped execution paths.

Triton

RPC and validator shred streaming

Price$0.08/GB plus $10/million RPC calls; shreds $900–$1,500/month/IP

Alongside RPC and streaming APIs, its Shred Streaming product forwards raw Solana shreds from validator and partner sources to customer-controlled network destinations. Consumers must reconstruct and decode that data themselves, making the service substantially more involved than receiving parsed account updates. A $125 prepaid deposit, valid for 12 months, is required. RPC costs $0.08/GB plus $10 per million calls; standard streaming costs $0.08/GB. At Triton's five currently supported locations, shred delivery costs $900/month per IP per data centre in London, New York and Tokyo, or $1,500 in Frankfurt and Amsterdam.

Choose it when your strategy requires direct access to raw validator data and you can operate the processing pipeline.

Watch out for packet reconstruction, deployment geography, and specialized feed charges that are separate from ordinary RPC usage.

QuickNode Lil’ JIT

Jito methods on a managed endpoint

PriceFrom $89/month plus underlying service and on-chain costs

QuickNode Lil’ JIT exposes Jito bundle functionality through an existing QuickNode Solana JSON-RPC endpoint. Its documented methods cover sending transactions or bundles, simulating a bundle, checking landing status, retrieving tip accounts, and inspecting recent tip levels. The add-on catalog lists pricing from $89 monthly, in addition to the underlying QuickNode service and on-chain costs.

Choose it when your searcher already runs on QuickNode and you want bundle operations inside that integration.

Watch out for recurring add-on charges and the fact that an accepted submission can still expire without inclusion.

Chainstack

Geyser streams and Warp routing

PriceGrowth $49/month; Geyser $49/month; Warp $0.15/send

Chainstack combines managed blockchain RPC infrastructure with optional services for automated traders. Its Yellowstone Geyser add-on streams Solana account, transaction, and block updates over gRPC, while Warp changes the submission path for Solana sendTransaction requests. Warp forwards those submissions through bloXroute's Trader API; ordinary reads continue through Chainstack's standard infrastructure. The Growth plan starts at $49 monthly and enables paid add-ons. Yellowstone Geyser begins at another $49 per month for two streams, while Warp charges $0.15 per submitted transaction.

Choose it when you want to combine Solana subscriptions and paid transaction routing within an existing Chainstack deployment.

Watch out for cumulative subscription and per-send fees. Warp is a routing service, not a native atomic bundle builder.

How to run a Solana arbitrage bot with Jito bundles

  1. Choose your execution model. For an automated setup, follow SolanaMevBot's on-chain bot installation and configuration documentation. For a custom searcher, create strategy logic that monitors liquidity pools, prices candidate routes, and builds the required swap instructions.
  2. Prepare infrastructure and a restricted wallet. Use a dedicated Solana wallet, keep SOL available for network fees and tips, and configure an RPC capable of reading current account state. Helius, Triton, and Chainstack offer relevant data services. Keep private signing keys outside application logs and externally accessible configuration files.
  3. Collect the market inputs. A custom bot can subscribe to pool-account changes through LaserStream or Yellowstone Geyser. Triton's raw shred feed is an alternative when your system can reconstruct transaction data. SolanaMevBot instead uses its observed-route feed to select candidate pools, then reads their current state through RPC.
  4. Calculate the execution economics. Estimate the return from each arbitrage leg using current pool reserves, liquidity, fees, and trade size. Include network and priority charges, the proposed Jito tip, anticipated slippage, and any bot fee. Set a minimum acceptable result rather than assuming the observed price difference remains available.
  5. Construct and simulate the transaction. For a custom strategy, assemble the swaps and settlement operations, including account assertions or minimum-output conditions where supported. Use a single atomic Solana transaction when the instructions fit, or construct a Jito-compatible bundle for dependent transactions. QuickNode Lil’ JIT exposes simulateBundle; standard Solana simulation can help validate individual transactions.
  6. Submit through the selected route. Send the signed bundle to Jito directly or through QuickNode Lil’ JIT, including a valid tip instruction. Alternatively, use an appropriate bloXroute submission mode, Helius Sender, or Chainstack Warp when the strategy calls for their supported transaction-routing behavior. These interfaces do not all provide identical atomicity or revert semantics.
  7. Verify execution and update accounting. Check bundle status and on-chain transaction signatures, then reconcile settlement balances, token-account changes, tips, and fees. Record unsuccessful attempts as well as completed trades, because repeated submissions can consume network resources even when no arbitrage position is opened.

Worked example (illustrative): A custom searcher identifies two hypothetical liquidity pools where a 10 SOL round trip would return 10.020 SOL before execution expenses. Its budget includes a 0.003 SOL Jito tip, 0.001 SOL in network and priority fees, and 0.002 SOL as a slippage allowance, leaving an estimated 0.014 SOL margin. If refreshed pool data or simulation indicates the remaining margin would fall below a configured 0.010 SOL threshold, the bot rejects that candidate rather than submitting it.

Solana MEV execution and wallet risks

Price movement, pool manipulation, liquidity withdrawal, competing searchers, and unsuccessful transaction attempts can turn an apparent arbitrage into a loss; bundle atomicity does not eliminate every network edge case, including transactions exposed through uncled-block handling. Use restricted wallets, verify program permissions and signing destinations, enforce strict capital and output limits, and inspect the actual tokens and accounts involved before authorizing transactions. Track cumulative tips, failed-submission costs, and realized balances rather than treating successful API responses or simulated profits as earnings.

Frequently asked questions

What is the difference between a Solana MEV bot and a sniper bot?

An MEV searcher typically exploits transaction-ordering or state-dependent opportunities such as arbitrage and liquidations. A sniper bot focuses on entering token markets around launches or other configured triggers, and does not necessarily perform arbitrage.

Can I use Jito bundles without running my own validator?

Yes. Searchers submit signed transactions to Jito's Block Engine API, which handles forwarding to compatible leaders; QuickNode Lil’ JIT provides another supported access route.

Do Solana MEV bots need Yellowstone gRPC?

No. A bot can obtain account state through RPC or use another data source. Geyser subscriptions become useful when a custom searcher needs continuous account or transaction updates without repeatedly polling.

Are Jito tips and Solana priority fees the same?

No. A Jito tip is an explicit SOL payment associated with bundle competition, while a priority fee is paid through Solana's compute-budget fee mechanism. A transaction can include both.

Can I combine Helius data with bloXroute transaction submission?

Yes. A searcher can read accounts or receive streams from Helius while forwarding signed transactions through bloXroute. The bot must manage consistency between its observed state, transaction blockhash, and execution conditions.

Does MEV protection guarantee a profitable trade?

No. Protection features primarily address transaction exposure or submission behavior, not the economics of a swap. A protected transaction can still suffer ordinary slippage, unfavorable pool changes, or failed execution.

Sources

Show all 17 sources