# RPC Fast Beam (Beta) ## Overview {% hint style="info" %} RPC Fast Beam is currently in beta. Core changes may be introduced as the product evolves. {% endhint %} **RPC Fast Beam** is a low-latency Solana transaction submission service for execution-sensitive systems. Beam routes signed transactions through partner delivery paths such as **SWQoS-backed validators**, **Jito Block Engine submission**, and other provider-specific low-latency infrastructure. This improves landing probability during congestion and reduces latency variance. Beam is built for HFT, MEV searchers, liquidation bots, arbitrage engines, latency-sensitive market makers, and apps that care about delivery quality. Beam is also useful for users who need maximum transaction protection from sandwich attacks, front-running, and toxic MEV. {% hint style="info" %} RPC Fast Beam is a **transaction delivery service** – not a general-purpose Solana RPC endpoint. {% endhint %} ### At a Glance | Capability | Details | | ---------------------- | ------------------------------------------------- | | Purpose | Fast Solana transaction delivery | | HTTP endpoint | `https://beam.rpcfast.com` | | Tip feed | `wss://beam.rpcfast.com/tips?provider=` | | Supported methods | `sendTransaction`, `sendBundle` | | Providers | `astralane`, `bloxroute`, `falcon` | | Modes | `fastest`, `mev_protect` | | Authorization | `api_key` query arg or `X-Token` header | | Availability | All plans | | CU cost | `5 CU` per `sendTransaction` request | | Rate limit | Start plan - `1 TPS`, paid plans - `15 TPS` | | Required on every send | Tip transfer instruction | | Ignored on send path | Node-side retries and preflight controls | *** ### How Beam Works When you send a transaction through Beam, it’s routed via your selected provider. Under the hood, Beam leverages provider-specific low-latency infrastructure – such as **SWQoS-backed validator paths**, **Jito Block Engine**, **Harmonic**, or **Rakurai** submission – to maximize how quickly your transaction reaches the current leader. In competitive conditions, this can significantly improve landing probability. This becomes critical in scenarios where packet delivery speed matters just as much as on-chain priority fees. For deeper background, see [SWQoS](https://docs.rpcfast.com/rpc-fast-saas-solana/sending-transactions/swqos) and [Aperture gRPC (Beta)](https://docs.rpcfast.com/rpc-fast-saas-solana/data-streaming/aperture-grpc-beta). #### Best practices To maximize reliability and performance, distribute your transaction submissions across multiple providers in parallel. This reduces reliance on any single route and improves overall resilience. *** ### Endpoints #### Transaction endpoint ```http https://beam.rpcfast.com ``` #### Tip guidance feed ```http wss://beam.rpcfast.com/tips?provider= ``` Replace `` with one of: ``` astralane bloxroute falcon ``` *** ### Authorization Beam accepts an API key through either of these methods: * `api_key` query argument * `X-Token` header #### Query argument ```bash curl 'https://beam.rpcfast.com/?api_key=' \ -X POST \ -H 'Content-Type: application/json' \ -d '{}' ``` #### Header ```bash curl 'https://beam.rpcfast.com/?mode=fastest&provider=bloxroute' \ -X POST \ -H 'Content-Type: application/json' \ -H 'X-Token: ' \ -d '{}' ``` *** ### Query Arguments Beam supports transaction mode selection and provider override through URL query arguments. #### Provider override ``` provider=astralane | bloxroute | falcon ``` If `provider` is not specified, Beam detects the provider from the tipping address you have included in your transaction. **Example** ``` https://beam.rpcfast.com/?provider=falcon ``` #### Mode ``` mode=fastest | mev_protect ``` If `mode` is not specified, Beam uses `fastest` by default. Supported modes depend on the selected provider. See [Providers](#providers). | Mode | Use when | Notes | | ------------- | ------------------------------------------------------------------------- | ---------------------------------------------------------------- | | `fastest` | Lowest possible submission latency matters most | Best for HFT, arbitrage, liquidations, and same-slot competition | | `mev_protect` | Protection against frontrunning, backrunning and sandwiching matters most | Best for sensitive order flow and execution privacy | Choose the mode that matches the intent of the transaction. *** ### Providers and Tips Every transaction sent through Beam **must include a valid tip** instruction. {% hint style="warning" %} RPC Fast Beam does not inject tip instructions automatically. Your application must append the provider-specific tip transfer before signing and sending. {% endhint %} Sending a transaction without a valid provider tip **is not supported** and will lead to send failure. It is strongly recommended to **rotate the tip account** on every transaction. #### Providers
ProviderTip accountsBundle supportMode support
Astralane
ASdXviZw2kbViFuAgZF26RPZL1HdybUoWdcveG2nfU8D
Ax2JBnTPUpBFWe75z3YtgueWUfvZPZ6ZFXiMWJMUnjbo
✅fastest, mev_protect
bloXroute
rfBP8KJ6KMqvBhmqaV7EoNHVexXQdn1sX4CJ9aLv5w2
rfBkmha9yK5QS7h562Pn6Bfw6cPjsrgVqgcnnXBoXj7
rfBxDPw4XK2WKBinv7Vbr68inD964H7HTMLMWshe3jT
✅fastest, mev_protect
Falcon by Corvus
rfCCxFtXuwjjnP9cXAaEgvCzLkrzXwAiWQadJ4uNKmf
rfCTcFU5p63roQ7S8sTwpQ93NHfGxf5ThSsbH1CjQbf
rfC18Jx6rqwhvwjWpkZnX8q7vE45vzxBXtic1jLr32R
rfCmxTvz2LeEzVmFZHvcfLvz4EaT6Rbkkff98RufbdZ
rfCaRhB66prehCypC53XeSPJ83cTjzwa8cHMeNpenQ8
❌fastest
`sendBundle` is supported only by `astralane` and `bloxroute`. `mev_protect` is supported only by `astralane` and `bloxroute`. #### Recommended tip amounts RPC Fast Beam provides real-time tip guidance over WebSocket. **WebSocket URL** ``` wss://beam.rpcfast.com/tips?provider=&api_key=YOUR_API_KEY ``` **Example response** ```json { "time": "2026-04-15T11:03:44Z", "provider": "bloxroute", "25th_percentile": 0.001, "50th_percentile": 0.001, "75th_percentile": 0.001, "95th_percentile": 0.001, "99th_percentile": 0.001 } ``` All percentile values are denominated in `SOL`. Higher percentiles generally improve landing probability during contention. Lower percentiles may be enough in quieter conditions. #### Provider score feed RPC Fast Beam provides real-time provider scoring feed over WebSocket. **WebSocket URL** ``` wss://beam.rpcfast.com/provider-scores?api_key=YOUR_API_KEY ``` **Example response** ```json [ { "provider": "bloxroute", "score": 0.9, "success_rate": 1.0, "landing_latency": 186.263, "landing_rate": 1.0 }, { "provider": "astralane", "score": 1.0, "success_rate": 1.0, "landing_latency": 95.177, "landing_rate": 1.0 }, { "provider": "falcon", "score": 0.95, "success_rate": 1.0, "landing_latency": 145.311, "landing_rate": 1.0 } ] ``` **Response fields** * `landing_latency` - delay between transaction received on Beam and first seen across shreds. * `landing_rate` - ratio of landed vs sent transactions * `success_rate` - ratio of valid vs sent transactions * `score` - computed score with following weights * 50 for landing\_rate * 30 for landing\_latency * 20 for success\_rate *** ### Pricing & Availability Beam is available on all RPC Fast plans! Transaction bundles support is available **only on paid plans**. #### Compute Units cost Each request costs **5 CU.** *** ### Rate limits RPC Fast Beam currently supports: * **1 TPS** on Start plan * **15 TPS** on all paid plans {% hint style="info" %} Beam is currently in beta, and rate limits are subject to change as the service evolves. {% endhint %} *** ### Supported JSON-RPC Methods Beam currently supports: * `sendTransaction` * `sendBundle` #### sendTransaction Submit a signed transaction using the standard Solana JSON-RPC payload. ```bash curl 'https://beam.rpcfast.com/' \ -X POST \ -H 'Content-Type: application/json' \ -d '{ "jsonrpc": "2.0", "id": 1, "method": "sendTransaction", "params": [ "", { "encoding": "base64" } ] }' ``` #### Ignored `sendTransaction` options Beam ignores Solana retry and preflight controls on the send path. The following parameters are ignored: * `maxRetries` * `skipPreflight=false` Retry logic must be implemented in your application. If a transaction does not land, rebuild or re-sign as needed and resubmit according to your own policy. #### sendBundle Use `sendBundle` when submitting bundles through a supported provider path. Supported providers: `astralane`, `bloxroute`. ```bash curl 'https://beam.rpcfast.com/?mode=fastest' \ -X POST \ -H 'Content-Type: application/json' \ -d '{ "jsonrpc": "2.0", "id": 1, "method": "sendBundle", "params": [ [ "", "" ] ] }' ``` {% hint style="info" %} Detailed `sendBundle` documentation is coming soon. {% endhint %} *** ### Code Examples The same rules apply in every language: * Reuse one RPC client across all sends. * Use HTTP/2. * Keep connections warm. * Enable keep-alive and TCP keepalive where supported. * Rotate the tip account for every transaction. * Append the tip instruction before signing. {% tabs %} {% tab title="Rust" %} ```rust use std::sync::atomic::{AtomicUsize, Ordering}; use std::time::Duration; use anyhow::{anyhow, Result}; use base64::Engine; use reqwest::{ header::{HeaderMap, HeaderValue, CONTENT_TYPE}, Client, }; use serde_json::{json, Value}; use solana_sdk::{ hash::Hash, instruction::Instruction, message::Message, pubkey::Pubkey, signature::{Keypair, Signature, Signer}, system_instruction, transaction::Transaction, }; const RPCFAST_TOKEN: &str = "YOUR_RPCFAST_TOKEN"; const SOLANA_RPC_URL: &str = "https://solana-rpc.rpcfast.com"; const BEAM_URL: &str = "https://beam.rpcfast.com/?mode=fastest"; const TIP_ACCOUNTS: [&str; 6] = [ // astralane "ASdXviZw2kbViFuAgZF26RPZL1HdybUoWdcveG2nfU8D", "Ax2JBnTPUpBFWe75z3YtgueWUfvZPZ6ZFXiMWJMUnjbo", // falcon "rfCCxFtXuwjjnP9cXAaEgvCzLkrzXwAiWQadJ4uNKmf", "rfCTcFU5p63roQ7S8sTwpQ93NHfGxf5ThSsbH1CjQbf", // bloxroute "rfBP8KJ6KMqvBhmqaV7EoNHVexXQdn1sX4CJ9aLv5w2", "rfBkmha9yK5QS7h562Pn6Bfw6cPjsrgVqgcnnXBoXj7", ]; pub struct JsonRpcClient { http: Client, rpc_url: String, } impl JsonRpcClient { pub fn new(rpc_url: impl Into, token: &str) -> Result { let mut headers = HeaderMap::new(); headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json")); headers.insert("X-Token", HeaderValue::from_str(token)?); let http = Client::builder() .default_headers(headers) .http2_prior_knowledge() .pool_idle_timeout(Duration::from_secs(90)) .pool_max_idle_per_host(64) .tcp_keepalive(Duration::from_secs(30)) .tcp_nodelay(true) .build()?; Ok(Self { http, rpc_url: rpc_url.into(), }) } pub async fn call(&self, method: &str, params: Value) -> Result { let payload = json!({ "jsonrpc": "2.0", "id": 1, "method": method, "params": params }); let value: Value = self .http .post(&self.rpc_url) .json(&payload) .send() .await? .error_for_status()? .json() .await?; if let Some(error) = value.get("error") { return Err(anyhow!("rpc error: {error}")); } value.get("result") .cloned() .ok_or_else(|| anyhow!("missing result field")) } } pub struct BeamClient { // Recent blockhashes should be fetched from the standard Solana RPC endpoint. solana_rpc: JsonRpcClient, // Beam supports only sendTransaction / sendBundle. beam_rpc: JsonRpcClient, tip_accounts: Vec, next_tip_idx: AtomicUsize, } impl BeamClient { pub fn new( solana_rpc_url: impl Into, beam_url: impl Into, token: &str, tip_accounts: &[&str], ) -> Result { if tip_accounts.is_empty() { return Err(anyhow!("tip account list must not be empty")); } let parsed_tip_accounts = tip_accounts .iter() .map(|s| s.parse::()) .collect::, _>>()?; Ok(Self { solana_rpc: JsonRpcClient::new(solana_rpc_url, token)?, beam_rpc: JsonRpcClient::new(beam_url, token)?, tip_accounts: parsed_tip_accounts, next_tip_idx: AtomicUsize::new(0), }) } fn next_tip_account(&self) -> Pubkey { let idx = self.next_tip_idx.fetch_add(1, Ordering::Relaxed) % self.tip_accounts.len(); self.tip_accounts[idx] } fn build_tip_instruction(&self, payer: &Pubkey, tip_lamports: u64) -> Result { if tip_lamports == 0 { return Err(anyhow!("Beam requires a tip instruction on every transaction")); } Ok(system_instruction::transfer( payer, &self.next_tip_account(), tip_lamports, )) } async fn get_latest_blockhash(&self) -> Result { let result = self .solana_rpc .call("getLatestBlockhash", json!([{ "commitment": "processed" }])) .await?; let blockhash = result["value"]["blockhash"] .as_str() .ok_or_else(|| anyhow!("missing blockhash"))?; Ok(blockhash.parse()?) } pub async fn send_transaction( &self, payer: &Keypair, mut instructions: Vec, tip_lamports: u64, ) -> Result { let blockhash = self.get_latest_blockhash().await?; instructions.push(self.build_tip_instruction(&payer.pubkey(), tip_lamports)?); let message = Message::new(&instructions, Some(&payer.pubkey())); let tx = Transaction::new(&[payer], message, blockhash); let raw_bytes = bincode::serialize(&tx)?; let raw_b64 = base64::engine::general_purpose::STANDARD.encode(raw_bytes); // Beam supports only sendTransaction / sendBundle. // maxRetries and preflight controls are ignored by Beam. let result = self .beam_rpc .call( "sendTransaction", json!([ raw_b64, { "encoding": "base64", "skipPreflight": true, "maxRetries": 0, "preflightCommitment": "processed" } ]), ) .await?; let sig = result .as_str() .ok_or_else(|| anyhow!("missing signature"))?; Ok(sig.parse()?) } } #[tokio::main] async fn main() -> Result<()> { let beam = BeamClient::new( SOLANA_RPC_URL, BEAM_URL, RPCFAST_TOKEN, &ASTRALANE_TIP_ACCOUNTS, )?; let payer = Keypair::new(); let instructions: Vec = vec![]; let signature = beam .send_transaction(&payer, instructions, 1_000_000) .await?; println!("{signature}"); Ok(()) } ``` {% endtab %} {% tab title="TypeScript" %} ```typescript import { Keypair, PublicKey, SystemProgram, Transaction, TransactionInstruction, Connection, } from "@solana/web3.js"; import { Agent, fetch } from "undici"; const RPCFAST_TOKEN = process.env.RPCFAST_TOKEN!; const MODE = "fastest"; const SOLANA_RPC_URL = "https://solana-rpc.rpcfast.com"; const BEAM_URL = `https://beam.rpcfast.com/?mode=${MODE}`; const TIP_ACCOUNTS = [ // astralane "ASdXviZw2kbViFuAgZF26RPZL1HdybUoWdcveG2nfU8D", "Ax2JBnTPUpBFWe75z3YtgueWUfvZPZ6ZFXiMWJMUnjbo", // falcon "rfCCxFtXuwjjnP9cXAaEgvCzLkrzXwAiWQadJ4uNKmf", "rfCTcFU5p63roQ7S8sTwpQ93NHfGxf5ThSsbH1CjQbf", // bloxroute "rfBP8KJ6KMqvBhmqaV7EoNHVexXQdn1sX4CJ9aLv5w2", "rfBkmha9yK5QS7h562Pn6Bfw6cPjsrgVqgcnnXBoXj7", ]; class RotatingTipAccounts { private idx = 0; constructor(private readonly accounts: string[]) { if (accounts.length === 0) { throw new Error("tip account list must not be empty"); } } next(): PublicKey { const pk = new PublicKey(this.accounts[this.idx]); this.idx = (this.idx + 1) % this.accounts.length; return pk; } } const tipAccounts = new RotatingTipAccounts(ASTRALANE_TIP_ACCOUNTS); // Reusable HTTP/2 client with keep-alive. // Node sockets use TCP_NODELAY by default. const dispatcher = new Agent({ allowH2: true, connections: 256, pipelining: 1, keepAliveTimeout: 10_000, keepAliveMaxTimeout: 60_000, }); const customFetch: typeof fetch = (input, init = {}) => fetch(input, { ...init, dispatcher, headers: { "Content-Type": "application/json", "X-Token": RPCFAST_TOKEN, ...(init.headers ?? {}), }, }); // Reuse both clients across the lifetime of the process. // Recent blockhashes should be fetched from the standard Solana RPC endpoint. const solanaRpc = new Connection(SOLANA_RPC_URL, { commitment: "processed", fetch: customFetch as any, }); // Beam supports only sendTransaction / sendBundle. const beamRpc = new Connection(BEAM_URL, { commitment: "processed", fetch: customFetch as any, }); function buildTipInstruction( payer: PublicKey, tipLamports: number, ): TransactionInstruction { if (tipLamports <= 0) { throw new Error("Beam requires a tip instruction on every transaction"); } return SystemProgram.transfer({ fromPubkey: payer, toPubkey: tipAccounts.next(), lamports: tipLamports, }); } export async function sendBeamTransaction( payer: Keypair, appInstructions: TransactionInstruction[], tipLamports: number, ): Promise { const { blockhash } = await solanaRpc.getLatestBlockhash("processed"); const tx = new Transaction({ feePayer: payer.publicKey, recentBlockhash: blockhash, }); for (const ix of appInstructions) { tx.add(ix); } tx.add(buildTipInstruction(payer.publicKey, tipLamports)); tx.sign(payer); const raw = tx.serialize(); // Beam supports only sendTransaction / sendBundle. // maxRetries and preflight controls are ignored by Beam and should be handled application-side. return beamRpc.sendRawTransaction(raw, { skipPreflight: true, maxRetries: 0, preflightCommitment: "processed", }); } ``` {% endtab %} {% tab title="Python" %} ```python import base64 import itertools from typing import Iterable, List, Any import httpx from solders.hash import Hash from solders.instruction import Instruction from solders.keypair import Keypair from solders.message import Message from solders.pubkey import Pubkey from solders.system_program import TransferParams, transfer from solders.transaction import Transaction RPCFAST_TOKEN = "YOUR_RPCFAST_TOKEN" MODE = "fastest" SOLANA_RPC_URL = "https://solana-rpc.rpcfast.com" BEAM_URL = f"https://beam.rpcfast.com/?mode={MODE}" ASTRALANE_TIP_ACCOUNTS = [ ## astralane "ASdXviZw2kbViFuAgZF26RPZL1HdybUoWdcveG2nfU8D", "Ax2JBnTPUpBFWe75z3YtgueWUfvZPZ6ZFXiMWJMUnjbo", ## falcon "rfCCxFtXuwjjnP9cXAaEgvCzLkrzXwAiWQadJ4uNKmf", "rfCTcFU5p63roQ7S8sTwpQ93NHfGxf5ThSsbH1CjQbf", ## bloxroute "rfBP8KJ6KMqvBhmqaV7EoNHVexXQdn1sX4CJ9aLv5w2", "rfBkmha9yK5QS7h562Pn6Bfw6cPjsrgVqgcnnXBoXj7", ]; class JsonRpcClient: def __init__(self, rpc_url: str, token: str) -> None: self.rpc_url = rpc_url self.request_id = 0 self.http = httpx.Client( http2=True, limits=httpx.Limits(max_connections=200, max_keepalive_connections=50), timeout=httpx.Timeout(5.0), headers={ "Content-Type": "application/json", "X-Token": token, }, ) def call(self, method: str, params: List[Any]) -> Any: self.request_id += 1 payload = { "jsonrpc": "2.0", "id": self.request_id, "method": method, "params": params, } response = self.http.post(self.rpc_url, json=payload) response.raise_for_status() data = response.json() if "error" in data: raise RuntimeError(data["error"]) return data["result"] class BeamClient: def __init__( self, solana_rpc_url: str, beam_url: str, token: str, tip_accounts: List[str], ) -> None: if not tip_accounts: raise ValueError("tip account list must not be empty") # Reuse both clients for the lifetime of the process. # Recent blockhashes should come from the standard Solana RPC endpoint. self.solana_rpc = JsonRpcClient(solana_rpc_url, token) # Beam supports only sendTransaction / sendBundle. self.beam_rpc = JsonRpcClient(beam_url, token) self.tip_accounts = itertools.cycle(Pubkey.from_string(x) for x in tip_accounts) def get_latest_blockhash(self) -> Hash: result = self.solana_rpc.call("getLatestBlockhash", [{"commitment": "processed"}]) return Hash.from_string(result["value"]["blockhash"]) def next_tip_account(self) -> Pubkey: return next(self.tip_accounts) def build_tip_instruction(self, payer: Pubkey, tip_lamports: int) -> Instruction: if tip_lamports <= 0: raise ValueError("Beam requires a tip instruction on every transaction") return transfer( TransferParams( from_pubkey=payer, to_pubkey=self.next_tip_account(), lamports=tip_lamports, ) ) def send_transaction( self, payer: Keypair, instructions: Iterable[Instruction], tip_lamports: int, ) -> str: blockhash = self.get_latest_blockhash() final_instructions = list(instructions) final_instructions.append(self.build_tip_instruction(payer.pubkey(), tip_lamports)) message = Message(final_instructions, payer.pubkey()) tx = Transaction([payer], message, blockhash) raw_tx_b64 = base64.b64encode(bytes(tx)).decode("ascii") # Beam supports only sendTransaction / sendBundle. # maxRetries and preflight controls are ignored by Beam. return self.beam_rpc.call( "sendTransaction", [ raw_tx_b64, { "encoding": "base64", "skipPreflight": True, "maxRetries": 0, "preflightCommitment": "processed", }, ], ) beam = BeamClient( solana_rpc_url=SOLANA_RPC_URL, beam_url=BEAM_URL, token=RPCFAST_TOKEN, tip_accounts=ASTRALANE_TIP_ACCOUNTS, ) payer = Keypair() # Example: # signature = beam.send_transaction( # payer=payer, # instructions=[...], # tip_lamports=1_000_000, # ) # print(signature) ``` {% endtab %} {% endtabs %} *** ### Best Practices For best results with RPC Fast Beam: * Always include a **valid tip transfer instruction.** * Use appropriate **tip account** when specifying `provider` query parameter. * **Rotate tip accounts** instead of hardcoding one destination. * Send transaction to **multiple providers in parallel** if supported. * Use the **WebSocket tip feed** to adapt tip size dynamically. * Reuse a long-lived RPC client. * Use HTTP/2 and keep connections warm. * Handle retries in the application. * Do not rely on preflight checks on the send path. * Keep your signing and submission path hot. * Combine Beam with sound transaction construction, including fresh blockhashes and sane fee logic. {% hint style="success" icon="light-emergency-on" %} **For latency-sensitive systems,** pair Beam with the [Aperture gRPC (Beta)](https://docs.rpcfast.com/rpc-fast-saas-solana/data-streaming/aperture-grpc-beta) to detect opportunities earlier. Teams that prefer lower-level data can also use **Shredstream,** with more client-side decoding work. {% endhint %} *** ### Quick Reference #### Endpoint ``` https://beam.rpcfast.com ``` #### Supported Solana RPC methods ``` sendTransaction sendBundle ``` #### Query arguments ``` provider=astralane | bloxroute | falcon mode=fastest | mev_protect ``` #### Defaults ``` provider=derived from the tip account used in transaction mode=fastest ``` #### Tip feed ``` wss://beam.rpcfast.com/tips?provider= ``` *** ### When to Use Beam Beam is a strong fit for: * High-frequency trading systems * MEV searchers * Liquidation bots * Arbitrage engines * Latency-sensitive market makers * Wallets or apps that need stronger delivery guarantees * Users who want protection from backrunning and sandwich attacks For standard, low-priority transaction flows, a regular Solana RPC endpoint may be sufficient.