RPC Fast Beam (Beta)

Solana transaction delivery for latency-sensitive workloads.

Overview

RPC Fast Beam is currently in beta. Core changes may be introduced as the product evolves.

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.

RPC Fast Beam is a transaction delivery service – not a general-purpose Solana RPC endpoint.

At a Glance

Capability

Details

Purpose

Fast Solana transaction delivery

HTTP endpoint

https://beam.rpcfast.com

Tip feed

wss://beam.rpcfast.com/tips?provider=<provider>

Provider score feed

wss://beam.rpcfast.com/provider-scores

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 request

Rate limit

Start plan - 60 txs/minute
Focus plan - 200 txs/minute
Stream, Aperture - 500 txs/minute

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 and 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.

Abuse prevention policy

Users are prohibited from abusing the platform infrastructure, including but not limited to excessive spam transaction generation, persistent failed bundle submissions, artificial traffic amplification, or any activity that negatively impacts platform stability, SWQoS partners, or other users of the service.

Because our sender service is currently provided in Beta, our abuse-detection systems, fair-use thresholds, rate limits, and enforcement policies may change at any time without prior notice. We reserve the right to make enforcement decisions at our sole discretion when necessary to protect the platform, infrastructure providers, or other users. Read more in Terms of Service.

Endpoints

Transactions submission endpoint

Supports sendTransaction and sendBundle methods.

https://beam.rpcfast.com

Tip guidance feed

wss://beam.rpcfast.com/tips?provider=<provider>

Replace <provider> 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

curl 'https://beam.rpcfast.com/?api_key=<your-api-key>' \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{}'

Header

curl 'https://beam.rpcfast.com/?mode=fastest&provider=bloxroute' \
  -X POST \
  -H 'Content-Type: application/json' \
  -H 'X-Token: <your-api-key>' \
  -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.

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 to the addresses provided in these docs.

RPC Fast Beam does not inject tip instructions automatically. Your application must append the provider-specific tip transfer before signing and sending.

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

Provider

Tip accounts

Bundle support

Mode 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=<provider>&api_key=YOUR_API_KEY

Example response

{
  "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

[
  {
    "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 submission is available only on paid plans.

Compute Units cost

Each transaction submission request costs 5 CU.

Rate limits

RPC Fast Beam currently offers:

60 transactions per minute on Start plan
200 transactions per minute on Focus plan
500 transactions per minute on Stream and Aperture plans

These limits apply to both sendTransaction and sendBundle methods. Each transaction in a bundle is taken into account when calculating the rate limit.

Please note that Beam has built-in spam classifier, so you need to maintain the quality of your transactions, otherwise rate limit penalties may be applied to your account.

For more info: Spam Transactions & Abuse Prevention Policy (Beta)

Beam is currently in beta, and rate limits are subject to change as the service evolves.

Supported JSON-RPC Methods

Beam currently supports:

sendTransaction
sendBundle

sendTransaction

Submit a signed transaction using the standard Solana JSON-RPC payload.

curl 'https://beam.rpcfast.com/' \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sendTransaction",
    "params": [
      "<base64-encoded-signed-transaction>",
      {
        "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. Bundles are mostly used in cases where you need atomic execution of transactions. These transactions are executed sequentially. If one of transaction fails the whole bundle gets reverted and never appears on-chain.

Supported providers: astralane, bloxroute.

curl 'https://beam.rpcfast.com/?mode=fastest' \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sendBundle",
    "params": [
      [
        "<base64-encoded-signed-transaction-1>",
        "<base64-encoded-signed-transaction-2>"
      ]
    ]
  }'

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.

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<String>, token: &str) -> Result<Self> {
        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<Value> {
        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<Pubkey>,
    next_tip_idx: AtomicUsize,
}

impl BeamClient {
    pub fn new(
        solana_rpc_url: impl Into<String>,
        beam_url: impl Into<String>,
        token: &str,
        tip_accounts: &[&str],
    ) -> Result<Self> {
        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::<Pubkey>())
            .collect::<std::result::Result<Vec<_>, _>>()?;

        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<Instruction> {
        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<Hash> {
        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<Instruction>,
        tip_lamports: u64,
    ) -> Result<Signature> {
        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<Instruction> = vec![];

    let signature = beam
        .send_transaction(&payer, instructions, 1_000_000)
        .await?;

    println!("{signature}");
    Ok(())
}

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<string> {
  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",
  });
}

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)

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.
Use only those tip accounts specified in our docs, otherwise request will be rejected.
Rotate tip accounts instead of hardcoding one destination.
Send transaction to multiple providers in parallel for better resilience.
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.

For latency-sensitive systems, pair Beam with the Aperture gRPC (Beta) to detect opportunities earlier. Teams that prefer lower-level data can also use Shredstream, with more client-side decoding work.

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=<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.

PreviousSWQoS NextSpam Transactions & Abuse Prevention Policy (Beta)

Last updated 6 days ago

Overview

At a Glance

How Beam Works

Best practices

Abuse prevention policy

Endpoints

Transactions submission endpoint

Tip guidance feed

Authorization

Query argument

Header

Query Arguments

Provider override

Mode

Providers and Tips

Providers

Recommended tip amounts

Provider score feed

Pricing & Availability

Compute Units cost

Rate limits

Supported JSON-RPC Methods

sendTransaction

Ignored sendTransaction options

sendBundle

Code Examples

Best Practices

Quick Reference

Endpoint

Supported Solana RPC methods

Query arguments

Defaults

Tip feed

When to Use Beam

Ignored `sendTransaction` options