Transaction Submission

OrBlock sends transactions through multiple optimized channels to achieve the best performance on the Solana network. Our service routes transactions through self-hosted nodes, staked validator connections, and bundle services to maximize transaction success rates.

sendTransaction

OrBlock is a service that supports the sendTransaction Solana RPC method. Simply use our URL where you would place a standard RPC URL. Transactions are intelligently routed through:

OrbitFlare’s high-performance self-hosted nodes
Premium staked validator connections
Bundle services when appropriate

Direct HTTP Endpoints

Amsterdam 🇳🇱: http://ams.orblock.orbitflare.com/?api_key=<api-key> Frankfurt 🇩🇪: http://fra.orblock.orbitflare.com/?api_key=<api-key> London 🇬🇧: http://lon.orblock.orbitflare.com/?api_key=<api-key> New York 🇺🇸: http://ny.orblock.orbitflare.com/?api_key=<api-key> Tokyo 🇯🇵: http://tok.orblock.orbitflare.com/?api_key=<api-key> Salt Lake City 🇺🇸: http://slc.orblock.orbitflare.com/?api_key=<api-key>

Secure HTTPS Endpoints

Amsterdam 🇳🇱: https://ams.orblock.orbitflare.com/?api_key=<api-key> Frankfurt 🇩🇪: https://fra.orblock.orbitflare.com/?api_key=<api-key> London 🇬🇧: https://lon.orblock.orbitflare.com/?api_key=<api-key> New York 🇺🇸: https://ny.orblock.orbitflare.com/?api_key=<api-key> Tokyo 🇯🇵: https://tok.orblock.orbitflare.com/?api_key=<api-key> Salt Lake City 🇺🇸: https://slc.orblock.orbitflare.com/?api_key=<api-key>

HTTP POST Body

{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sendTransaction",
    "params": [ 
        "<base64_encoded_tx>",
        { "encoding": "base64" }
    ] 
}

Add your API key after ?api_key=<api-key> to create your custom URL for sending transactions. OrBlock’s regional submission endpoints are strategically placed across Europe (Amsterdam, Frankfurt, London), North America (New York, Salt Lake City), and Asia (Tokyo) to minimize latency worldwide. All nodes run on enterprise-grade hardware with custom optimizations for transaction processing. Please specify base64 encoding for optimal performance.

Transaction Priority Fee

OrBlock intelligently routes your transaction to the network scheduler. At this point, priority fees matter for processing speed. We recommend setting the compute unit (CU) price to at least 1,000,000 for optimal performance, especially during network congestion.

Retries and Confirmations

OrBlock automatically retries transactions until confirmation or expiry. The system will prioritize retries based on:

Transaction priority fee
Historical success rate of similar transactions
Current network conditions

Rate Limits

Each API key has an associated rate limit based on your OrbitFlare plan:

Plan	Transactions Per Second (TPS)
Starter Orbit	50 TPS
Advanced Nebula	100 TPS
Ultimate Cosmos	150 TPS
OrbitFlare Pass	300 TPS per location

Quality of Service

Clients with consistently high transaction failure rates will experience a QoS adjustment to their priority. For example, if only 20% of your transactions successfully land on-chain, your priority may be adjusted accordingly. This is based on your transaction performance over the past 30 minutes.

Optimized Routing

What makes OrBlock unique is how it intelligently routes transactions through the Transaction Processing Unit (TPU). Our system analyzes network conditions, validator performance, and transaction characteristics to determine the optimal submission strategy. OrBlock does not simulate transactions by default, which reduces latency. Optional simulation can be enabled through configuration parameters.

Front-Running Protection

OrBlock offers optional front-running protection through special submission endpoints. These endpoints utilize optimized bundle services and private transaction pools. Set strict slippage tolerances and calculate minAmountOut values to have additional protection against front-running.

Code Examples

CURL

curl https://ny.orblock.orbitflare.com/?api_key=YOUR_API_KEY \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sendTransaction",
    "params": [
      "4hXTCkRzt9WyecNzV1XPgCDfGAZzQKNxLXgynz5QDuWWPSAZBZSHptvWRL3BjCvzUXRdKvHL2b7yGrRQcWyaqsaBCncVG7BFggS8w9snUts67BSh3EqKpXLUm5UMHfD7ZBe9GhARjbNQMLJ1QD3Spr6oMTFNhyKNMr3WNFCrXgDS7uV7u",
      {
        "encoding": "base64",
        "commitment": "confirmed"
      }
    ]
  }'

JavaScript

const sendTransaction = async (connection, transaction, signers) => {
  // Add a recent blockhash to the transaction
  transaction.recentBlockhash = (
    await connection.getRecentBlockhash()
  ).blockhash;
  
  // Sign the transaction with all required signers
  transaction.sign(...signers);
  
  // Convert transaction to wire format
  const rawTransaction = transaction.serialize();
  
  // Send the raw transaction
  const signature = await connection.sendRawTransaction(
    rawTransaction,
    {
      skipPreflight: false,
      preflightCommitment: 'confirmed',
      maxRetries: 5
    }
  );
  
  // Wait for confirmation
  const confirmation = await connection.confirmTransaction(
    signature,
    'confirmed'
  );
  
  return {
    signature,
    confirmation
  };
};

// Example usage with OrBlock
const connection = new Connection('https://ny.orblock.orbitflare.com/?api_key=YOUR_API_KEY');
const result = await sendTransaction(connection, transaction, signers);
console.log('Transaction signature:', result.signature);

TypeScript

import { 
  Connection, 
  Transaction, 
  PublicKey, 
  SystemProgram, 
  Keypair 
} from '@solana/web3.js';

// Initialize connection to OrBlock
const connection = new Connection('https://ny.orblock.orbitflare.com/?api_key=YOUR_API_KEY');

// Create and send transaction
const sendTransaction = async (
  fromKeypair: Keypair,
  toPublicKey: PublicKey,
  lamports: number
) => {
  const transaction = new Transaction().add(
    SystemProgram.transfer({
      fromPubkey: fromKeypair.publicKey,
      toPubkey: toPublicKey,
      lamports
    })
  );

  // Get recent blockhash
  const { blockhash } = await connection.getRecentBlockhash();
  transaction.recentBlockhash = blockhash;
  transaction.feePayer = fromKeypair.publicKey;
  
  // Sign transaction
  transaction.sign(fromKeypair);
  
  // Send transaction
  const signature = await connection.sendRawTransaction(
    transaction.serialize(),
    {
      skipPreflight: false,
      preflightCommitment: 'confirmed',
      maxRetries: 5
    }
  );
  
  // Wait for confirmation
  const confirmation = await connection.confirmTransaction(signature, 'confirmed');
  
  return {
    signature,
    confirmation: {
      status: confirmation.value.err ? 'failed' : 'success',
      slot: confirmation.context.slot
    }
  };
};

Python

from solana.rpc.api import Client
from solana.transaction import Transaction
from solana.system_program import TransferParams, transfer
from solana.keypair import Keypair
from solana.publickey import PublicKey
import base64

# Initialize connection to OrBlock
client = Client("https://ny.orblock.orbitflare.com/?api_key=YOUR_API_KEY")

def send_transaction(from_keypair, to_pubkey, lamports):
    # Create transfer instruction
    transfer_ix = transfer(
        TransferParams(
            from_pubkey=from_keypair.public_key,
            to_pubkey=to_pubkey,
            lamports=lamports
        )
    )
    
    # Get recent blockhash
    blockhash_resp = client.get_recent_blockhash()
    blockhash = blockhash_resp["result"]["value"]["blockhash"]
    
    # Create and sign transaction
    transaction = Transaction()
    transaction.add(transfer_ix)
    transaction.recent_blockhash = blockhash
    transaction.sign(from_keypair)
    
    # Serialize and send transaction
    serialized_transaction = base64.b64encode(transaction.serialize()).decode("utf-8")
    resp = client.send_transaction(
        serialized_transaction,
        opts={"encoding": "base64", "skipPreflight": False, "preflightCommitment": "confirmed"}
    )
    
    # Return signature
    return resp["result"]

# Example usage
from_keypair = Keypair.generate()
to_pubkey = PublicKey("Recipient_Public_Key_Here")
signature = send_transaction(from_keypair, to_pubkey, 1000000)
print(f"Transaction signature: {signature}")

Rust

use solana_client::rpc_client::RpcClient;
use solana_sdk::{
    signature::{Keypair, Signer},
    system_instruction,
    transaction::Transaction,
    pubkey::Pubkey,
    commitment_config::CommitmentConfig,
};
use std::str::FromStr;

fn main() {
    // Initialize connection to OrBlock
    let rpc_url = "https://ny.orblock.orbitflare.com/?api_key=YOUR_API_KEY";
    let client = RpcClient::new_with_commitment(
        rpc_url.to_string(),
        CommitmentConfig::confirmed(),
    );
    
    // Create keypair and destination public key
    let from_keypair = Keypair::new();
    let to_pubkey = Pubkey::from_str("Recipient_Public_Key_Here").unwrap();
    let lamports = 1_000_000;
    
    // Create transfer instruction
    let instruction = system_instruction::transfer(
        &from_keypair.pubkey(),
        &to_pubkey,
        lamports,
    );
    
    // Get recent blockhash
    let recent_blockhash = client.get_latest_blockhash().unwrap();
    
    // Create and sign transaction
    let mut transaction = Transaction::new_with_payer(
        &[instruction],
        Some(&from_keypair.pubkey()),
    );
    transaction.sign(&[&from_keypair], recent_blockhash);
    
    // Send transaction
    let signature = client.send_transaction(&transaction).unwrap();
    println!("Transaction signature: {}", signature);
    
    // Confirm transaction
    let confirmation = client.confirm_transaction(&signature).unwrap();
    println!("Transaction confirmed: {}", confirmation);
}

Go

package main

import (
	"context"
	"encoding/base64"
	"fmt"
	"log"

	"github.com/gagliardetto/solana-go"
	"github.com/gagliardetto/solana-go/rpc"
	"github.com/gagliardetto/solana-go/rpc/types"
	"github.com/gagliardetto/solana-go/programs/system"
)

func main() {
	// Initialize connection to OrBlock
	endpoint := "https://ny.orblock.orbitflare.com/?api_key=YOUR_API_KEY"
	client := rpc.New(endpoint)
	
	// Create keypair and destination
	fromKeypair := solana.NewWallet()
	toPubkey, err := solana.PublicKeyFromBase58("Recipient_Public_Key_Here")
	if err != nil {
		log.Fatalf("Invalid public key: %v", err)
	}
	
	// Create transfer instruction
	instruction := system.NewTransferInstruction(
		1_000_000,
		fromKeypair.PublicKey(),
		toPubkey,
	).Build()
	
	// Get recent blockhash
	recentBlockhash, err := client.GetRecentBlockhash(
		context.Background(),
		rpc.CommitmentConfirmed,
	)
	if err != nil {
		log.Fatalf("Failed to get recent blockhash: %v", err)
	}
	
	// Create and sign transaction
	tx, err := solana.NewTransaction(
		[]solana.Instruction{instruction},
		recentBlockhash.Value.Blockhash,
		solana.TransactionPayer(fromKeypair.PublicKey()),
	)
	if err != nil {
		log.Fatalf("Failed to create transaction: %v", err)
	}
	
	_, err = tx.Sign(func(key solana.PublicKey) *solana.PrivateKey {
		if fromKeypair.PublicKey().Equals(key) {
			return &fromKeypair.PrivateKey
		}
		return nil
	})
	if err != nil {
		log.Fatalf("Failed to sign transaction: %v", err)
	}
	
	// Serialize and send transaction
	serializedTx, err := tx.Serialize()
	if err != nil {
		log.Fatalf("Failed to serialize transaction: %v", err)
	}
	
	encodedTx := base64.StdEncoding.EncodeToString(serializedTx)
	signature, err := client.SendTransactionWithOpts(
		context.Background(),
		encodedTx,
		types.TransactionOpts{
			SkipPreflight:       false,
			PreflightCommitment: rpc.CommitmentConfirmed,
			MaxRetries:          5,
		},
	)
	if err != nil {
		log.Fatalf("Failed to send transaction: %v", err)
	}
	
	fmt.Printf("Transaction signature: %s\n", signature.String())
}

Jupiter Swap Example

Here’s an example of using OrBlock to execute a Jupiter swap transaction:

import { Connection } from '@solana/web3.js';
import { Jupiter } from '@jup-ag/core';

// Initialize connection to OrBlock
const connection = new Connection('https://ny.orblock.orbitflare.com/?api_key=YOUR_API_KEY');

async function executeJupiterSwap(
  fromTokenMint,
  toTokenMint,
  amount,
  slippageBps,
  wallet
) {
  // Initialize Jupiter
  const jupiter = await Jupiter.load({
    connection,
    cluster: 'mainnet-beta',
    user: wallet,
  });
  
  // Get routes
  const routes = await jupiter.computeRoutes({
    inputMint: fromTokenMint,
    outputMint: toTokenMint,
    amount,
    slippageBps,
  });
  
  // Select best route
  const bestRoute = routes.routesInfos[0];
  
  // Execute swap
  const { txid } = await jupiter.exchange({
    routeInfo: bestRoute,
  });
  
  console.log('Swap transaction submitted:', txid);
  
  // Wait for confirmation
  const confirmation = await connection.confirmTransaction(txid, 'confirmed');
  
  return {
    signature: txid,
    success: !confirmation.value.err,
    route: bestRoute.routeName,
  };
}

Contact

For enterprise plans, custom rate limits, and dedicated support, please contact our team:

Email: support@orbitflare.com
Discord: discord.gg/orbitflare
Twitter: @orbitflarenodes

For technical issues or feature requests, please open a ticket on our Discord server.

​Transaction Submission

​sendTransaction

​Direct HTTP Endpoints

​Secure HTTPS Endpoints

​HTTP POST Body

​Transaction Priority Fee

​Retries and Confirmations

​Rate Limits

​Quality of Service

​Optimized Routing

​Front-Running Protection

​Code Examples

​CURL

​JavaScript

​TypeScript

​Python

​Rust

​Go

​Jupiter Swap Example

​Contact