API Documentation

Features & Advantages

Proprietary technology with ultra-low latency optimization, transactions reach leaders faster, leading confirmation speed.

Pricing and Rate Limits

Plan	Entry	Intermediate	Advanced
Price	FREE!	FREE!	FREE!
TPS	5 TPS	50 TPS	100 TPS
SWQoS	Dedicated SWQoS	Dedicated SWQoS	Dedicated SWQoS
Transaction Tip	0.001 SOL	0.001 SOL	0.0001 SOL

Quick Start

Contact us to get an API Key.

Authentication

• Protocol: HTTP/HTTPS
• Response Format: JSON (the health endpoint returns plain text "ok")
• Header:

shell
1Content-Type: application/json
2x-api-key: <YOUR_API_KEY>

• Timezone: UTC
• Note: The health endpoint does not require x-api-key, all other write operation endpoints require it.

API Overview

Endpoint Name	Description	Method
health	Check the health status of the current API node	GET
sendTransaction	Native Solana JSON-RPC sendTransaction method	POST
submitBatch	Non-atomic batch submission of multiple signed transactions (each transaction processed independently)	POST
sendBundle	Atomic bundle submission of multiple signed transactions (all fail if any transaction fails)	POST

health

• Function: Check the health status of the current API endpoint
• Method: GET/POST
• Path: /health
• Request Parameters: None
• Response

Field	Type	Description
result	string	Fixed as "OK" to indicate the endpoint is available

• Example:
  • Request GET http://ny.rpc.blockrush.io/health
  • Response 200 OK

sendTransaction

• Function: Proxy Solana's sendTransaction JSON-RPC, directly forwarding a single signed transaction to Stacked Validator for processing
• Method: POST
• Path: /
• Header: Content-Type: application/json
• Request Parameters

Field	Type	Required	Description	Example
params	string	Yes	Fully signed transaction, Base64 encoded string	See below
encoding	string	Yes	Transaction encoding format, must match the actual transaction encoding	base64

• Response

Field	Type	Description
result	string	The result will be the same as described in the Solana RPC documentation

• Example Request:

shell
1curl -X POST 'https:// ny.rpc.blockrush.io ' \
2-H 'Content-Type: application/json' \
3-H 'x-api-key: <YOUR_API_KEY>' \
4-d '{
5  "jsonrpc": "2.0",
6  "id": 1,
7  "method": "sendTransaction",
8  "params": [
9    "<base64_encoded_tx>",
10    { "encoding": "base64" }
11  ]
12}'

• Example Response:

json
1{
2  "jsonrpc": "2.0",
3  "result": "<tx_signature>"
4  "id": 1
5}

submitBatch

• Function: Batch forward multiple signed transactions to the validator for processing in a single request; non-atomic, unordered processing, each transaction executed independently
• Non-atomicity: Each transaction is confirmed and returned independently, failure of one does not affect others.
• Method: POST
• Path: /submit-batch
• Header: Content-Type: application/json
• Request Parameters

Field	Type	Required	Description	Example
transactions	array[string]	Yes	Fully signed transactions, Base64 encoded strings. Maximum 5 transactions.	See below
options	array[string]	Yes	Reserved field, currently use empty array	[]

• Response

Field	Type	Description
signatures	array[string]	List of transaction signatures corresponding to the transactions list

• Example Request:

shell
1curl -X POST 'https:// ny.rpc.blockrush.io/submit-batch ' \
2-H 'Content-Type: application/json' \
3-H 'x-api-key: <YOUR_API_KEY>' \
4-d '{
5  "jsonrpc": "2.0",
6  "id": 1,
7  "params": {
8    "options": [],
9    "transactions": [
10      "<base64_encoded_tx_001>",
11      "<base64_encoded_tx_002>",
12      "<base64_encoded_tx_003>",
13      "<base64_encoded_tx_004>",
14      "<base64_encoded_tx_005>"
15    ]
16  }
17}'

• Example Response:

json
1{
2  "code": 1,
3  "message": "success"
4  "signatures": [
5    "<tx_001_signature>",
6    "<tx_002_signature>",
7    "<tx_003_signature>",
8    "<tx_004_signature>",
9    "<tx_005_signature>"
10  ]
11}

sendBundle

Note: By default, API Keys do not have sendBundle enabled, you need to contact customer service to enable it

• Function: Submit a bundle list composed of multiple signed transactions to the cluster for processing; executed atomically in sequence, entire bundle rejected if any transaction fails
• Strong Atomicity: Failure of any transaction in the sequence will cause the entire bundle to be rejected.
• Method: POST
• Path: /
• Header: Content-Type: application/json
• Request Parameters

Field	Type	Required	Description	Example
params	array[string]	Yes	Fully signed transactions, Base64 encoded strings. Maximum 5 transactions.	See below
encoding	string	Yes	Transaction encoding format, must match the actual transaction encoding	base64

• Response

Field	Type	Description
result	string	Bundle ID used to identify this bundle. This is the SHA-256 hash of the bundle transaction signatures.

• Example Request:

shell
1curl -X POST 'https:// ny.rpc.blockrush.io ' \
2-H 'Content-Type: application/json' \
3-H 'x-api-key: <YOUR_API_KEY>' \
4-d '{
5  "jsonrpc": "2.0",
6  "id": 1,
7  "method": "sendBundle",
8  "params": [
9    [
10      "<base64_encoded_tx_001>",
11      "<base64_encoded_tx_002>",
12      …
13      "<base64_encoded_tx_005>",
14    ],
15    { "encoding": "base64" }
16  ]
17}'

• Example Response:

json
1{
2  "jsonrpc": "2.0",
3  "result": "<bundle_signature>"
4  "id": 1
5}

API Comparison and Recommendations

Requirement	Recommended Endpoint	Description
Single transaction direct send	sendTransaction	Simplest path, returns transaction signature
Multiple transactions, high throughput, mutually independent	submitBatch	Non-atomic, failure of one does not affect others
Multiple transactions, require strong consistency	sendBundle	All fail if any fails
Health check and operations	health	Returns ok

Best Practices

• Choose the geographically closest endpoint to reduce latency
• For batch submissions, balance between atomicity (sendBundle) and throughput (submitBatch) according to requirements

SDK

We have prepared commonly used SDK tools for developers.

Rust

Explore BlockRush Rust JSON-RPC, a high-performance SDK designed to leverage Rust's powerful features to interact with BlockRush infrastructure on Solana.

• Environment Support: Rust 1.75+, Tokio async runtime
• Feature Recommendations: Enable rustls or native-tls, use connection pooling and timeout control in production environments
• Dependencies and Import

toml
1[dependencies]  
2blockrush-sdk = { path = "path/to/blockrush-sdk-0.1.0.crate" }  
3tokio = { version = "1", features = ["full"] }  
4serde = { version = "1", features = ["derive"] }  
5serde_json = "1"  

• Quick Start and Testing

rust
1#[tokio::test]  
2async fn test_blockrush_sdk() {  
3    let sdk = BlockrushSdk::new(Region::JP, "xxxxxx").await.unwrap();  
4    assert_eq!(sdk.region(), Region::JP);  
5
6    let tx_data = "ASN=".to_string();  
7
8    let resp: SdkResponse<serde_json::Value> = sdk.send_transaction(tx_data).await.unwrap();  
9    println!("{:?}", resp.body);  
10
11    let resp2: SdkResponse<serde_json::Value> = sdk.submit_batch(&vec!["ASN=".to_string()]).await.unwrap();  
12    println!("{:?}", resp2.body);  
13}

JavaScript and TypeScript

The BlockRush JS JSON-RPC library provides similar functionality tailored for Node.js and browser environments, optimized for efficient SWQoS interactions.

• Environment Support: Node.js 20+, modern browsers (supporting fetch/AbortController)
• Security Tip: Do not hardcode production API Keys in the browser. You can use backend-issued short-term tokens or proxy forwarding

javascript
1import { BlockrushSDK, Region } from "../blockrush-nodejs-sdk/index.js";  
2
3const sdk = new BlockrushSDK({  
4  region: Region.JP,  
5  api_key: "YOUR_API_KEY", // Example key, in production use environment variables, config files, etc.
6});  
7
8// This request demonstrates the submit_batch API
9const res = await sdk.submit_batch([  
10  "Base64 string of fully signed transaction 1",  
11  "Base64 string of fully signed transaction 2",  
12]);  
13console.log(res);  
14
15// This request demonstrates the send_transaction API
16const res2 = await sdk.send_transaction(
17"Base64 string of fully signed transaction 3"
18);  
19console.log(res2);
20
21sdk.destroy();  

Priority Fees and Tips

Using our SWQoS, you can use default priority fees (no need to set them specifically), using tips as the priority option. When constructing transactions, you need to add a tip transfer instruction to the transaction to speed up inclusion in blocks.

The base64-encoded tx data generated by the example code can be directly called through SDK methods, for example passed to send_transaction.

Rust

rust
1pub const MEMO_PROGRAM_ID: &str = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
2pub const BLOCKRUSH_TIP_WALLET: &str = "AhMVT9KWLGjBbzvdqQkTt4vHwpawnGNoGSqaqXYftNDR";
3pub const DEFAULT_TIP_AMOUNT: u64 = 1_000_000; // 0.001 SOL
4
5pub fn create_blockrush_tip_ix(pubkey: Pubkey, tip_amount:u64) -> Instruction {
6    let tip_ix =
7        instruction::transfer(
8            &pubkey,
9            &Pubkey::from_str(BLOCKRUSH_TIP_WALLET).unwrap(),
10            tip_amount,
11        );
12    tip_ix
13}
14
15fn create_memo_tx_with_tip(msg: &[u8], payer: &Keypair, blockhash: Hash) -> Transaction {
16    let memo = Pubkey::from_str(MEMO_PROGRAM_ID).unwrap();
17    let instruction = Instruction::new_with_bytes(memo, msg, vec![]);
18    let mut instructions = vec![instruction];
19    let tip_ix = create_blockrush_tip_ix(payer.pubkey(), TIP_AMOUNT);
20    instructions.push(tip_ix);
21    let message = Message::new(&instructions, Some(&payer.pubkey()));
22    Transaction::new(&[payer], message, blockhash)
23}
24
25let test_tx = create_memo_tx_with_tip(b"this is a demo tx", &keypair, latest_hash);
26let serialized_test_tx = bincode::serialize(&test_tx)?;
27let base64_test_tx = BASE64_STANDARD.encode(&serialized_test_tx);

JavaScript and TypeScript

javascript
1const ixs = {your instructions ixs};
2const keypair = {your_actual_keypair};
3const TIP_AMOUNT = 1_000_000; // 0.001 SOL;
4const BLOCKRUSH_TIP = new PublicKey("AhMVT9KWLGjBbzvdqQkTt4vHwpawnGNoGSqaqXYftNDR");
5
6// Append Tip payment instruction
7ixs.push(
8    SystemProgram.transfer({
9        fromPubkey: keypair.publicKey,
10        toPubkey: BLOCKRUSH_TIP,
11        lamports: TIP_AMOUNT,
12    }),
13);
14
15// Compile and sign transaction instructions
16const messageV0 = new TransactionMessage({
17    payerKey: keypair.publicKey,
18    recentBlockhash: latestBlockhash.blockhash,
19    instructions: ixs,
20}).compileToV0Message();
21const transaction = new VersionedTransaction(messageV0);
22transaction.sign([keypair]);
23
24// Get Base64 encoded string of fully signed transaction
25const transactionRaw = Buffer.from(transaction.serialize()).toString('base64');

Error Handling

Error responses typically include error descriptions and optional error codes. It is recommended to record request ID/error information for troubleshooting.

• Success Case:

json
1{
2  "jsonrpc": "2.0",
3  "result": "3TEjEHSHPfNp5frqxVW...",
4  "id": 1
5}

• Failure Cases:

API key invalid or missing

json
1{
2  "jsonrpc": "2.0",
3  "error":  { "code": -32602, message: "Invalid API Key. ", data: null },
4  "id": 1
5}

Method Error:

json
1{
2  "jsonrpc": "2.0",
3  "error":  { "code": -32601, message: "Method no found.", data: null },
4  "id": 1
5}

Rate Limits

HTTP code returns 429.

Regional Nodes

Location	Protocol	Endpoint
🇺🇸 New York	https/http	ny.rpc.blockrush.io
🇩🇪 Frankfurt	https/http	fra.rpc.blockrush.io
🇯🇵 Tokyo	https/http	jp.rpc.blockrush.io