SolanaMevBotSending 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. Each sender's limit, or a key's own limit, is shared across all routes and both settlement profiles. 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 exceptions are harmonic, which submits to Harmonic's block engine over gRPC, and Jito keys with grpc_urls. 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, so tip_accounts is optional; the example lists the same eight. 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 }
# Optional: these are the built-in defaults.
tip_accounts = [
"96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5",
"HFqU5x63VTqvQss8hp11i4wVV8bD44PvwucfZ2bU7gRe",
"Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY",
"ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49",
"DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh",
"ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt",
"DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL",
"3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT",
]Jito with several uuids and gRPC
Requires bot 2.0.4 or later. Jito rate limits each uuid separately, and gRPC separately from HTTP. To send more bundles per second, give each uuid its own key, add a key for gRPC, and set rate_limit_per_second on each. Each such key gets its own lane with its own limit. With OneByOne, as here, each submission takes one lane, so the sender can send up to the sum of those limits: 11 submissions per second in this example. Set each rate to what Jito allows that uuid or connection.
With OneByOne, each submission goes through the next lane that has room under its limit, starting with that lane's next region. It tries the lane's other regions on a connection failure, timeout, or server error. When every region of the lane is unreachable, or the lane is rate limited, the submission moves on to another lane that has room. A rate-limit reply pauses only that lane, for two seconds. With AllAtOnce, each submission goes through every lane that has room, to every region of each.
A gRPC key lists block-engine URLs without /api/v1 in grpc_urls instead of urls, and must set its own rate_limit_per_second. It takes no uuid, auth_header, or request_params. Without auth_keypair, its bundles are sent unauthenticated, and Jito accepts one per second, so the example sets 1. With it, the bot signs in as the keypair in that file (a JSON byte array, like a Solana CLI keypair), whose public key must be approved by Jito for searcher access; raise the rate to what Jito grants that key. That key does not need to be your trading wallet. A missing or invalid file is a config error. Leave auth_keypair unset until Jito has approved the key: while Jito refuses it, the lane fails to sign in at every region on each submission, logging each failure, and OneByOne then passes the submission to another lane.
Keys without their own rate_limit_per_second share the sender's limit; if every key sets its own, leave the sender's unset. ip_addresses applies only to HTTP keys, so a sender whose keys are all gRPC rejects it; gRPC connects from the machine's default address. ip_addresses also turns use_separate_tip_account on by default for the whole sender, gRPC keys included, unless you set it to false. Logs hide uuids, so they name a key with its own rate by its position counting from 0, such as jito keys[1] for the second key; keys that share the sender's limit log under the sender's name.
[[senders]]
name = "jito"
type = "jito"
sending_strategy = "OneByOne"
no_failure_mode = true
tip_amount = { strategy = "ExponentialRandom", from = 1000, to = 5000, count = 1 }
[[senders.keys]]
urls = [
"https://ny.mainnet.block-engine.jito.wtf/api/v1",
"https://frankfurt.mainnet.block-engine.jito.wtf/api/v1",
]
uuid = "YOUR_FIRST_JITO_UUID"
rate_limit_per_second = 5
[[senders.keys]]
urls = [
"https://ny.mainnet.block-engine.jito.wtf/api/v1",
"https://frankfurt.mainnet.block-engine.jito.wtf/api/v1",
]
uuid = "YOUR_SECOND_JITO_UUID"
rate_limit_per_second = 5
[[senders.keys]]
grpc_urls = [
"https://ny.mainnet.block-engine.jito.wtf",
"https://frankfurt.mainnet.block-engine.jito.wtf",
]
rate_limit_per_second = 1 # unauthenticated; raise it with an approved auth_keypair
# auth_keypair = "~/jito-auth.json" # optional: a key Jito approvedHarmonic
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",
"FASTYKWXRfAoty7SQCM1mGVrmPUyyNcF4tc3DUkLDAu9",
"FASTPB76TxKPMZ7Q29m8v4zJn8gUjbWyvTEQaaxhwN7M",
"FASTs6ctgbsuZegMzUs4DPUYhRSZUPCjgCVnttHbpQAp",
"FASTYmSidNfLwdwiQEhCTtzghxEtaipeNSDSwh9xDPs3",
"FASTCKnwwY6iL3CknRgg3Zqir7jeagDDhxSnBQQy5a1C",
"FASTKL1AamNKrwnvbKwo4PU8434BBdqVrTtugM6oDU71",
]
no_failure_mode = trueCircular 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",
"FASTYKWXRfAoty7SQCM1mGVrmPUyyNcF4tc3DUkLDAu9",
"FASTPB76TxKPMZ7Q29m8v4zJn8gUjbWyvTEQaaxhwN7M",
"FASTs6ctgbsuZegMzUs4DPUYhRSZUPCjgCVnttHbpQAp",
"FASTYmSidNfLwdwiQEhCTtzghxEtaipeNSDSwh9xDPs3",
"FASTCKnwwY6iL3CknRgg3Zqir7jeagDDhxSnBQQy5a1C",
"FASTKL1AamNKrwnvbKwo4PU8434BBdqVrTtugM6oDU71",
]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",
"astra9xWY93QyfG6yM8zwsKsRodscjQ2uU2HKNL5prk",
"astraRVUuTHjpwEVvNBeQEgwYx9w9CFyfxjYoobCZhL",
"astraEJ2fEj8Xmy6KLG7B3VfbKfsHXhHrNdCQx7iGJK",
"astraubkDw81n4LuutzSQ8uzHCv4BhPVhfvTcYv8SKC",
"astraZW5GLFefxNPAatceHhYjfA1ciq9gvfEg2S47xk",
"astrawVNP4xDBKT7rAdxrLYiTSTdqtUr63fSMduivXK",
"AstrA1ejL4UeXC2SBP4cpeEmtcFPZVLxx3XGKXyCW6to",
"AsTra79FET4aCKWspPqeSFvjJNyp96SvAnrmyAxqg5b7",
"AstrABAu8CBTyuPXpV4eSCJ5fePEPnxN8NqBaPKQ9fHR",
"AsTRADtvb6tTmrsqULQ9Wji9PigDMjhfEMza6zkynEvV",
"AsTRAEoyMofR3vUPpf9k68Gsfb6ymTZttEtsAbv8Bk4d",
"AStrAJv2RN2hKCHxwUMtqmSxgdcNZbihCwc1mCSnG83W",
"Astran35aiQUF57XZsmkWMtNCtXGLzs8upfiqXxth2bz",
"AStRAnpi6kFrKypragExgeRoJ1QnKH7pbSjLAKQVWUum",
"ASTRaoF93eYt73TYvwtsv6fMWHWbGmMUZfVZPo3CRU9C",
]
no_failure_mode = trueAstralane 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",
"astra9xWY93QyfG6yM8zwsKsRodscjQ2uU2HKNL5prk",
"astraRVUuTHjpwEVvNBeQEgwYx9w9CFyfxjYoobCZhL",
"astraEJ2fEj8Xmy6KLG7B3VfbKfsHXhHrNdCQx7iGJK",
"astraubkDw81n4LuutzSQ8uzHCv4BhPVhfvTcYv8SKC",
"astraZW5GLFefxNPAatceHhYjfA1ciq9gvfEg2S47xk",
"astrawVNP4xDBKT7rAdxrLYiTSTdqtUr63fSMduivXK",
"AstrA1ejL4UeXC2SBP4cpeEmtcFPZVLxx3XGKXyCW6to",
"AsTra79FET4aCKWspPqeSFvjJNyp96SvAnrmyAxqg5b7",
"AstrABAu8CBTyuPXpV4eSCJ5fePEPnxN8NqBaPKQ9fHR",
"AsTRADtvb6tTmrsqULQ9Wji9PigDMjhfEMza6zkynEvV",
"AsTRAEoyMofR3vUPpf9k68Gsfb6ymTZttEtsAbv8Bk4d",
"AStrAJv2RN2hKCHxwUMtqmSxgdcNZbihCwc1mCSnG83W",
"Astran35aiQUF57XZsmkWMtNCtXGLzs8upfiqXxth2bz",
"AStRAnpi6kFrKypragExgeRoJ1QnKH7pbSjLAKQVWUum",
"ASTRaoF93eYt73TYvwtsv6fMWHWbGmMUZfVZPo3CRU9C",
]
request_params = { mevProtect = true, revertProtection = true }Temporal Nozomi
Use the JSON-RPC endpoint and put your key after c=. It takes v1 transactions up to 4,096 bytes. To send bundles instead, see Temporal Nozomi bundles. 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",
"noz3str9KXfpKknefHji8L1mPgimezaiUyCHYMDv1GE",
"noz6uoYCDijhu1V7cutCpwxNiSovEwLdRHPwmgCGDNo",
"noz9EPNcT7WH6Sou3sr3GGjHQYVkN3DNirpbvDkv9YJ",
"nozc5yT15LazbLTFVZzoNZCwjh3yUtW86LoUyqsBu4L",
"nozFrhfnNGoyqwVuwPAW4aaGqempx4PU6g6D9CJMv7Z",
"nozievPk7HyK1Rqy1MPJwVQ7qQg2QoJGyP71oeDwbsu",
"noznbgwYnBLDHu8wcQVCEw6kDrXkPdKkydGJGNXGvL7",
"nozNVWs5N8mgzuD3qigrCG2UoKxZttxzZ85pvAQVrbP",
"nozpEGbwx4BcGp6pvEdAh1JoC2CQGZdU6HbNP1v2p6P",
"nozrhjhkCr3zXT3BiT4WCodYCUFeQvcdUkM7MqhKqge",
"nozrwQtWhEdrA6W8dkbt9gnUaMs52PdAv5byipnadq3",
"nozUacTVWub3cL4mJmGCYjKZTnE9RbdY5AP46iQgbPJ",
"nozWCyTPppJjRuw2fpzDhhWbW355fzosWSzrrMYB1Qk",
"nozWNju6dY353eMkMqURqwQEoM3SFgEKC6psLCSfUne",
"nozxNBgWohjR75vdspfxR5H9ceC7XXH99xpxhVGt3Bb",
]Temporal Nozomi bundles
Requires bot 2.0.4 or later. Use type = "temporal" to send bundles through Nozomi's Send Bundle. Each URL names a regional host and your key after c=, such as https://fra2.nozomi.temporal.xyz/?c=YOUR_API_KEY, and the bot posts to its /api/sendBundle. The regional hosts are pit1, ewr1, ash1, lax1, fra2, ams1, lon1, tyo1, and sgp1. Nozomi does not forward bundles between regions, so list every region you want to reach: the sender sends each bundle to all of its URLs at once.
A bundle lands whole or not at all, so a bundle that reverts pays nothing. tip_amount is required, at least your key's minimum, by default 1,000,000 lamports. Tips go to Nozomi's tip accounts unless you list tip_accounts. request_params is not accepted.
Transactions go up to v1's 4,096 bytes, as with your other senders. Nozomi's documentation still limits bundle transactions to 1,232 bytes; while that holds, Nozomi rejects larger ones with Transaction too large, and Temporal Nozomi with json_rpc takes them instead.
The default rate_limit_per_second is 5, Nozomi's limit for a new key in each region. A submission counts once, however many regions it goes to.
[[senders]]
name = "temporal-bundle"
type = "temporal"
urls = [
"https://fra2.nozomi.temporal.xyz/?c=YOUR_API_KEY",
"https://ams1.nozomi.temporal.xyz/?c=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 }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",
"7toBU3inhmrARGngC7z6SjyP85HgGMmCTEwGNRAcYnEK",
"8mR3wB1nh4D6J9RUCugxUpc6ya8w38LPxZ3ZjcBhgzws",
"6SiVU5WEwqfFapRuYCndomztEwDjvS5xgtEof3PLEGm9",
"TpdxgNJBWZRL8UXF5mrEsyWxDWx9HQexA9P1eTWQ42p",
"D8f3WkQu6dCF33cZxuAsrKHrGsqGP2yvAHf8mX6RXnwf",
"GQPFicsy3P3NXxB5piJohoxACqTvWE9fKpLgdsMduoHE",
"Ey2JEr8hDkgN8qKJGrLf2yFjRhW7rab99HVxwi5rcvJE",
"4iUgjMT8q2hNZnLuhpqZ1QtiV8deFPy2ajvvjEpKKgsS",
"3Rz8uD83QsU8wKvZbgWAPvCNDU6Fy8TSZTMcPm3RB6zt",
"DiTmWENJsHQdawVUUKnUXkconcpW4Jv52TnMWhkncF6t",
"HRyRhQ86t3H4aAtgvHVpUJmw64BDrb61gRiKcdKUXs5c",
"7y4whZmw388w1ggjToDLSBLv47drw5SUXcLk6jtmwixd",
"J9BMEWFbCBEjtQ1fG5Lo9kouX1HfrKQxeUxetwXrifBw",
"8U1JPQh3mVQ4F5jwRdFTBzvNRQaYFQppHQYoH38DJGSQ",
"Eb2KpSC8uMt9GmzyAEm5Eb1AAAgTjRaXWFjKyFXHZxF3",
"FCjUJZ1qozm1e8romw216qyfQMaaWKxWsuySnumVCCNe",
"ENxTEjSQ1YabmUpXAdCgevnHQ9MHdLv8tzFiuiYJqa13",
"6rYLG55Q9RpsPGvqdPNJs4z5WTxJVatMB8zV3WJhs5EK",
"Cix2bHfqPcKcM233mzxbLk14kSggUUiz2A87fJtGivXr",
]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 = [
"NextbLoCkVtMGcV47JzewQdvBpLqT9TxQFozQkN98pE",
"NexTbLoCkWykbLuB1NkjXgFWkX9oAtcoagQegygXXA2",
"NeXTBLoCKs9F1y5PJS9CKrFNNLU1keHW71rfh7KgA1X",
"NexTBLockJYZ7QD7p2byrUa6df8ndV2WSd8GkbWqfbb",
"neXtBLock1LeC67jYd1QdAa32kbVeubsfPNTJC1V5At",
"nEXTBLockYgngeRmRrjDV31mGSekVPqZoMGhQEZtPVG",
"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",
"9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
"5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
"2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
"2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
"wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
"3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
"4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
"4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or",
]
request_params = { skipPreflight = true, maxRetries = 0 }Helius Sender bundles
Use type = "send_bundle" to submit each transaction as a Helius Sender Max bundle with JSON-RPC sendBundle. A bundle that would revert is dropped instead of landing, so a failed attempt costs neither its tip nor its fees. Use the global https://sender.helius-rpc.com/fast or the regional endpoint closest to you: slc, ewr, lon, fra, ams, sg, or tyo, as http://REGION-sender.helius-rpc.com/fast. Sender needs no API key. Add ?mev-protect=true to the URL for Helius's MEV protection.
Helius requires a tip of at least 0.001 SOL to its own tip accounts; no separate Jito tip is needed. Each transaction must also pay a priority fee of at least 5,000 lamports, which is the compute unit price times the transaction's compute unit limit: 50,000 micro-lamports per CU covers any limit of 100,000 CU or more.
[[senders]]
name = "helius-bundle"
type = "send_bundle"
urls = ["http://fra-sender.helius-rpc.com/fast"]
rate_limit_per_second = 1
compute_unit_price = { strategy = "Random", from = 50_000, to = 60_000, count = 1 }
tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
tip_accounts = [
"4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
"D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
"9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
"5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
"2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
"2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
"wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
"3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
"4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
"4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or",
]OrbitFlare Apex
OrbitFlare Apex sends each transaction to the upcoming leaders over stake-weighted connections, Jito, and direct TPU at once. Use the endpoint closest to you, http://REGION.apex.orbitflare.com with fra, ams, dub, lon, nyc, slc, sgp, tyo, or sqq, and send your API key from Dashboard > Apex in the x-api-key header.
Apex requires a tip of at least 0.001 SOL to its own tip accounts; no separate Jito tip is needed. Your key's tier sets that floor and the rate limit: the standard tier allows 5 transactions a second. See Apex tips and rate limits.
[[senders]]
name = "apex"
type = "json_rpc"
urls = ["http://fra.apex.orbitflare.com"]
rate_limit_per_second = 5
auth_header = "x-api-key"
auth_value = "YOUR_APEX_API_KEY"
no_failure_mode = false
compute_unit_price = { strategy = "Random", from = 10_000, to = 20_000, count = 1 }
tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
tip_accounts = [
"APeX2oLtjYehgTMUCA971L8htM7tGNqsXHDz5NrivhhX",
"APeXAKT6spXSmU3uRv2MoEgQ7ckhAS4nexTgaxwLEfJ9",
"APeXB4mu1X7BSjwyPtiNUnKyhvc4wrq5SKEdmnPKWR95",
"APeXJTSGoxLWmwb9o1tiiEL5RXVUakazYgjLmZdDc2Ef",
"APeXUUaKFfPXjPxKHEdwCsJ4BfTuGg4qnVQyJE9K37PU",
"APeXVWXKDRAAujckMjmMsV61a4DQiXa98MPUAkL46sim",
"APeXW6PKFZRDz7WXBBybBMcoJaQo97UtLa5TAQnchNBY",
"APeXZuKaKuqouyfU8fFL1woeWvSEVFkY4EMrmkvbfhhD",
"APeXbYdbmrYWsastf6GurexGe3dwnuWKLD2mcsDoEuBU",
"APeXn29deoxpsZz6r7n63Ymmv2skBr3WhKYLB1mB2fR7",
]OrbitFlare Apex sendBundle
Use type = "send_bundle" to submit each transaction as an Apex bundle with JSON-RPC sendBundle, using the same endpoint, key, and tip accounts. Bundles land only on Jito leaders: when the current leader does not run Jito, a bundle waits for the next one that does. A bundle that would revert is dropped instead of landing, so a failed attempt costs neither its tip nor its fees. Apex allows 2 bundles a second per key, on top of the key's transaction limit.
[[senders]]
name = "apex-bundle"
type = "send_bundle"
urls = ["http://fra.apex.orbitflare.com"]
rate_limit_per_second = 2
auth_header = "x-api-key"
auth_value = "YOUR_APEX_API_KEY"
compute_unit_price = { strategy = "Random", from = 10_000, to = 20_000, count = 1 }
tip_amount = { strategy = "Random", from = 1_000_000, to = 1_000_000, count = 1 }
tip_accounts = [
"APeX2oLtjYehgTMUCA971L8htM7tGNqsXHDz5NrivhhX",
"APeXAKT6spXSmU3uRv2MoEgQ7ckhAS4nexTgaxwLEfJ9",
"APeXB4mu1X7BSjwyPtiNUnKyhvc4wrq5SKEdmnPKWR95",
"APeXJTSGoxLWmwb9o1tiiEL5RXVUakazYgjLmZdDc2Ef",
"APeXUUaKFfPXjPxKHEdwCsJ4BfTuGg4qnVQyJE9K37PU",
"APeXVWXKDRAAujckMjmMsV61a4DQiXa98MPUAkL46sim",
"APeXW6PKFZRDz7WXBBybBMcoJaQo97UtLa5TAQnchNBY",
"APeXZuKaKuqouyfU8fFL1woeWvSEVFkY4EMrmkvbfhhD",
"APeXbYdbmrYWsastf6GurexGe3dwnuWKLD2mcsDoEuBU",
"APeXn29deoxpsZz6r7n63Ymmv2skBr3WhKYLB1mB2fR7",
]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",
"Lucum2g9HQeHdXEaENapK66C9bgprAMADsg1XijoW2m",
"Lucum3TJzgBRMZV5CgkmsH6jnE9YKa9ceAQDrUQQuA6",
"Lucum3TosrLyi8nwP9L9E6s9HWRTg8Y8kv67MjWpkKk",
"Lucum3yhZeqqXxW3yeTRheBRqwwXnr285HzTiyWKrgm",
"Lucum4XaQeeARcS4EwmJsGpjNWUNH75hAD2k7jsxSKD",
"Lucum4r22CCf5M5Zsj4PvhxYJ8CGz4QQMUCrL89Rupz",
"Lucum5FeurZkc7qrKadaWmzsZ6L1ig79EHGXJU65rPn",
"Lucum6s8rtKN5n7oWMm1h2Afm18DxWuA8Fgmraikxa3",
]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",
"moon7fwyajcVstMoBnVy7UBcTx87SBtNoGGAaH2Cb8V",
"moonBtH9HvLHjLqi9ivyrMVKgFUsSfrz9BwQ9khhn1u",
"moonCJg8476LNFLptX1qrK8PdRsA1HD1R6XWyu9MB93",
"moonF2sz7qwAtdETnrgxNbjonnhGGjd6r4W4UC9284s",
"moonKfftMiGSak3cezvhEqvkPSzwrmQxQHXuspC96yj",
"moonQBUKBpkifLcTd78bfxxt4PYLwmJ5admLW6cBBs8",
"moonXwpKwoVkMegt5Bc776cSW793X1irL5hHV1vJ3JA",
"moonZ6u9E2fgk6eWd82621eLPHt9zuJuYECXAYjMY1C",
]
no_failure_mode = true