SolanaMevBotSolanaMevBot
Onchain Bot

Sending Vendor Examples

RPC, Jito, Harmonic, and relay sender configurations for SolanaMevBot 2.0.0

Add the sender blocks you want to a complete 2.0.0 config. Every entry uses [[senders]] with a unique name and an explicit type. Replace API key placeholders and choose the endpoint for your region.

The limits below are example bot-side caps, not your provider's allowance. Match rate_limit_per_second, tip amounts, and credentials to your service plan. Limits are shared across all routes and both settlement profiles for each sender. Tips are in lamports; compute unit prices are in micro-lamports per CU.

Senders submit over HTTP, where the type selects the request format; it does not enable a provider's QUIC or gRPC interface. The exception is harmonic, which submits to Harmonic's block engine over gRPC. See Sender Fields for defaults and Tips and No-Failure Mode for the cost implications of successful no-trade transactions.

Standard RPC

Use a full RPC endpoint that supports sendTransaction. The read RPC in [bot] may use the same URL, but sending must still be configured here.

[[senders]]
name = "rpc"
type = "json_rpc"
urls = ["https://YOUR_SENDING_RPC"]
rate_limit_per_second = 5
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
request_params = { maxRetries = 0 }

Jito

Use block-engine URLs ending in /api/v1; the bot adds /bundles. Jito tip accounts are built in. Replace YOUR_JITO_UUID with your UUID, or remove the uuid line if you do not use one.

This example uses OneByOne, Jito’s default strategy. Each submission starts with the next region in the list and tries another on a connection failure, timeout, or HTTP server error. An accepted or rejected submission stops there. The default limit of one submission per second is shared across all routes and settlements. no_failure_mode = true allows a successful no-trade result, which can still pay its tip and network fees.

[[senders]]
name = "jito"
type = "jito"
urls = [
  "https://ny.mainnet.block-engine.jito.wtf/api/v1",
  "https://tokyo.mainnet.block-engine.jito.wtf/api/v1",
  "https://slc.mainnet.block-engine.jito.wtf/api/v1",
  "https://amsterdam.mainnet.block-engine.jito.wtf/api/v1",
  "https://frankfurt.mainnet.block-engine.jito.wtf/api/v1",
  "https://singapore.mainnet.block-engine.jito.wtf/api/v1",
  "https://london.mainnet.block-engine.jito.wtf/api/v1",
]
sending_strategy = "OneByOne"
uuid = "YOUR_JITO_UUID"
use_separate_tip_account = false
no_failure_mode = true
tip_amount = { strategy = "ExponentialRandom", from = 1000, to = 5000, count = 1 }

Harmonic

Requires bot 2.0.2 or later. Use type = "harmonic" to send bundles to Harmonic's block engine over gRPC. Pick the region closest to you: fra, lon, ams, ewr, tyo, sgp, or slc, as https://REGION.be.harmonic.gg. Harmonic forwards every bundle to all regions, so one URL is enough.

Harmonic has no tip accounts. Validators are paid through the compute unit price, so a harmonic sender requires compute_unit_price and rejects tip_amount. The price is your bid, and all of it goes to the validator. It is in micro-lamports per CU, charged on the transaction's compute unit limit: 10,000 on a 300,000-CU limit is 3,000 lamports. Harmonic requires a price of at least 10,000.

Without auth_keypair, bundles go to Harmonic's public service, which needs no key but is rate limited more strictly. For higher limits, request searcher access from Harmonic and set auth_keypair to the keypair file (a JSON byte array, like a Solana CLI keypair) of the public key Harmonic whitelisted. It does not need to be your trading wallet: the bot only signs in with it, and keeps its access token renewed. Leave auth_keypair unset until Harmonic has whitelisted the key. A key that cannot sign in does not fall back to the public service; the sender sends nothing and logs each failed attempt.

Harmonic drops bundles that revert and revokes access for flow that keeps reverting, including on the public service. Keep no_failure_mode = true so a transaction that finds no profitable trade succeeds instead of reverting. That transaction still pays its compute unit price and network fees.

[[senders]]
name = "harmonic"
type = "harmonic"
urls = ["https://fra.be.harmonic.gg"]
# auth_keypair = "~/harmonic-auth.json" # optional: a key Harmonic whitelisted
no_failure_mode = true
compute_unit_price = { strategy = "Random", from = 10_000, to = 20_000, count = 1 }

Fast from Circular.fi

The SMB endpoint takes JSON-RPC transactions, requires no_failure_mode = true, and specifies a 7,500-lamport minimum tip. Put your Circular key in auth_value.

[[senders]]
name = "circular-smb"
type = "json_rpc"
urls = ["https://fast.circular.fi/transactions/no-failure/smb"]
rate_limit_per_second = 1
auth_header = "x-api-key"
auth_value = "YOUR_API_KEY"
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
tip_amount = { strategy = "Random", from = 7_500, to = 7_500, count = 1 }
tip_accounts = [
  "FAST3dMFZvESiEipBvLSiXq3QCV51o3xuoHScqRU6cB6",
  "FASTHPW6akdGh9PFSdhMTbCuGkCSX7LsUjjnaB2RTQ4v",
]
no_failure_mode = true

Circular general endpoint

Use this alternative for the regular Circular endpoint. Choose either this sender or the SMB example unless you want to submit through both.

[[senders]]
name = "circular"
type = "json_rpc"
urls = ["https://fast.circular.fi/transactions"]
rate_limit_per_second = 1
auth_header = "x-api-key"
auth_value = "YOUR_API_KEY"
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
tip_accounts = [
  "FAST3dMFZvESiEipBvLSiXq3QCV51o3xuoHScqRU6cB6",
  "FASTHPW6akdGh9PFSdhMTbCuGkCSX7LsUjjnaB2RTQ4v",
]

Astralane

The bot supplies a shared default key when no key is provided for an Astralane endpoint. That path requires no_failure_mode = true. To use your own key, add auth_header = "api_key" and auth_value = "YOUR_API_KEY", or add ?api-key=YOUR_API_KEY to the URL. See Astralane for service access.

[[senders]]
name = "astralane"
type = "json_rpc"
urls = ["https://ny.gateway.astralane.io/iris"]
rate_limit_per_second = 1
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
tip_amount = { strategy = "Random", from = 10_000, to = 10_000, count = 1 }
tip_accounts = [
  "astrazznxsGUhWShqgNtAdfrzP2G83DzcWVJDxwV9bF",
  "astra4uejePWneqNaJKuFFA8oonqCE1sqF6b45kDMZm",
]
no_failure_mode = true

Astralane sendBundle

Use type = "send_bundle" to submit to Astralane with JSON-RPC sendBundle. This example uses your own key. The bot sends each price/tip variant separately; old bundle-group and max_transactions_per_request settings no longer apply. Provider options belong in request_params; see Astralane’s submission documentation.

[[senders]]
name = "astralane-bundle"
type = "send_bundle"
urls = ["https://ny.gateway.astralane.io/iris"]
rate_limit_per_second = 1
auth_header = "api_key"
auth_value = "YOUR_API_KEY"
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
tip_amount = { strategy = "Random", from = 10_000, to = 10_000, count = 1 }
tip_accounts = [
  "astrazznxsGUhWShqgNtAdfrzP2G83DzcWVJDxwV9bF",
  "astra4uejePWneqNaJKuFFA8oonqCE1sqF6b45kDMZm",
]
request_params = { mevProtect = true, revertProtection = true }

Temporal Nozomi

Use the JSON-RPC endpoint and put your key after c=. See Nozomi documentation for regional endpoints and tipping requirements.

[[senders]]
name = "temporal"
type = "json_rpc"
urls = ["https://ewr1.nozomi.temporal.xyz/?c=YOUR_API_KEY"]
rate_limit_per_second = 1
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
tip_accounts = [
  "TEMPaMeCRFAS9EKF53Jd6KpHxgL47uWLcpFArU1Fanq",
  "noz3jAjPiHuBPqiSPkkugaJDkJscPuRhYnSpbi8UvC4",
]

0slot

The 0slot quickstart uses JSON-RPC sendTransaction and URL authentication. Choose the region and tip amount appropriate to your plan.

[[senders]]
name = "0slot"
type = "json_rpc"
urls = ["https://ny.0slot.trade?api-key=YOUR_API_KEY"]
rate_limit_per_second = 1
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
tip_accounts = [
  "6fQaVhYZA4w3MBSXjJ81Vf6W1EDYeUPXpgVQ6UQyU1Av",
  "4HiwLEP2Bzqj3hM2ENxJuzhcPCdsafwiet3oGkMkuQY4",
]

NextBlock

Set type = "next_block" for the /api/v2/submit request body and use an authorization header. The bot does not accept request_params for this type. See NextBlock’s HTTP API.

[[senders]]
name = "nextblock"
type = "next_block"
urls = ["http://ny.nextblock.io/api/v2/submit"]
rate_limit_per_second = 1
auth_header = "authorization"
auth_value = "YOUR_API_KEY"
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
tip_accounts = [
  "NEXTbLoCkB51HpLBLojQfpyVAMorm3zzKg7w9NFdqid",
  "nextBLoCkPMgmG8ZgJtABeScP35qLa2AMCNKntAP7Xc",
]

Helius Sender

This example uses Helius Sender Max with a 0.001 SOL tip. Sending through Helius is separate from using the Helius compute-price strategy: either can be configured independently.

[[senders]]
name = "helius"
type = "json_rpc"
urls = ["https://sender.helius-rpc.com/fast"]
rate_limit_per_second = 1
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
tip_accounts = [
  "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
  "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
]
request_params = { skipPreflight = true, maxRetries = 0 }

Lucum

Use Lucum’s HTTP endpoint with your own key in the URL. The example keeps the 0.001 SOL tip. See Lucum for access and endpoint details.

[[senders]]
name = "lucum"
type = "json_rpc"
urls = ["http://fra.lucum.io/?api-key=YOUR_API_KEY"]
rate_limit_per_second = 1
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
tip_accounts = [
  "Lucum3sDVsPmHnQVaRKGpLXVPQLhcUqJqmcN5Tn9xuR",
  "Lucum2REE14nX1xBJee9RR24gMaM878icjigfuvWy7H",
]

FlashBlock

The FlashBlock batch endpoint takes a transactions array and an Authorization header. Use type = "submit_batch". Replace YOUR_FLASHBLOCK_TIP_ACCOUNT with a tip address supplied by FlashBlock, add your API key, and set enabled = true. This template is disabled until those values are filled in; the bot rejects an invalid tip public key on an enabled sender.

[[senders]]
name = "flashblock"
type = "submit_batch"
enabled = false
urls = ["http://ny.flashblock.trade/api/v2/submit-batch"]
rate_limit_per_second = 1
auth_header = "authorization"
auth_value = "YOUR_API_KEY"
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
tip_accounts = [
  "YOUR_FLASHBLOCK_TIP_ACCOUNT",
]

Hello Moon (Lunar Lander)

This is the no-failure endpoint example. Put your key in the URL and retain no_failure_mode = true. See Lunar Lander documentation for service details.

[[senders]]
name = "hellomoon"
type = "json_rpc"
urls = ["http://arb.lunar-lander.hellomoon.io/nofail?api-key=YOUR_API_KEY"]
rate_limit_per_second = 1
compute_unit_price = { strategy = "Random", from = 1000, to = 2000, count = 1 }
tip_amount = { strategy = "Random", from = 10_000, to = 10_000, count = 1 }
tip_accounts = [
  "moon17L6BgxXRX5uHKudAmqVF96xia9h8ygcmG2sL3F",
  "moon26Sek222Md7ZydcAGxoKG832DK36CkLrS3PQY4c",
]
no_failure_mode = true

Config Examples

Complete SOL, USDC, and combined configurations for SolanaMevBot 2.0.0

Wrap/Unwrap SOL

Manage WSOL trading capital and native SOL for fees

On this page

Standard RPCJitoHarmonicFast from Circular.fiCircular general endpointAstralaneAstralane sendBundleTemporal Nozomi0slotNextBlockHelius SenderLucumFlashBlockHello Moon (Lunar Lander)