Helius Sender: Ultra-Low Latency Solana Transaction Submission

Overview

Helius Sender is a specialized service for ultra-low latency transaction submission. It optimizes transaction latency by sending to both Solana validators and Jito simultaneously, providing multiple pathways for your transactions to be included in blocks.

Dual Routing

Sends to both validators and Jito for optimal speed

Global Endpoints

HTTPS endpoint auto-routes to nearest location for frontends, regional HTTP for backends

No Credits

Available on all plans without consuming API credits

High Throughput

Default 6 TPS, contact us for higher limits

Quick Start Guide

Ready to submit your first ultra-low latency Solana transaction? This guide will get you started with Helius Sender in minutes. The best part: you don’t need any paid plan or special access - Sender is available to all users and doesn’t consume API credits.

Create Your Free Helius Account

Start by creating your free account at the Helius Dashboard. Sender is available on all plans, including the free tier, and doesn’t consume any API credits.

Get Your API Key

Navigate to the API Keys section and copy your key. You’ll use this for getting blockhashes and transaction confirmation, while Sender handles the transaction submission.

Send Your First Transaction

Let’s send a simple SOL transfer using Sender. This example includes all required components: tip, priority fee, and skipped preflight.

import { 
  Connection, 
  TransactionMessage,
  VersionedTransaction,
  SystemProgram, 
  PublicKey,
  Keypair,
  LAMPORTS_PER_SOL,
  ComputeBudgetProgram
} from '@solana/web3.js';
import bs58 from 'bs58';

const TIP_ACCOUNTS = [
  "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
  "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ", 
  "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta"
  // ... more tip accounts available
];

async function sendWithSender(
  keypair: Keypair, 
  recipientAddress: string
): Promise<string> {
  const connection = new Connection(
    'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY'
  );
  
  const { value: { blockhash } } = await connection.getLatestBlockhashAndContext('confirmed');
  
  // Build transaction with tip transfer and transfer to recipient
  const transaction = new VersionedTransaction(
    new TransactionMessage({
      instructions: [
        ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }),
        ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }),
        SystemProgram.transfer({
          fromPubkey: keypair.publicKey,
          toPubkey: new PublicKey(recipientAddress),
          lamports: 0.001 * LAMPORTS_PER_SOL,
        }),
        SystemProgram.transfer({
          fromPubkey: keypair.publicKey,
          toPubkey: new PublicKey(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
          lamports: 0.001 * LAMPORTS_PER_SOL,
        })
      ],
      payerKey: keypair.publicKey,
      recentBlockhash: blockhash,
    }).compileToV0Message()
  );

  transaction.sign([keypair]);
  console.log('Sending transaction via Sender endpoint...');

  const response = await fetch('https://sender.helius-rpc.com/fast', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: Date.now().toString(),
      method: 'sendTransaction',
      params: [
        Buffer.from(transaction.serialize()).toString('base64'),
        {
          encoding: 'base64',
          skipPreflight: true, // Required for Sender
          maxRetries: 0
        }
      ]
    })
  });
  
  const json = await response.json();
  if (json.error) {
    throw new Error(json.error.message);
  }
  
  console.log('Transaction sent:', json.result);
  return json.result;
}

// Usage
const keypair = Keypair.fromSecretKey(bs58.decode('YOUR_PRIVATE_KEY'));
sendWithSender(keypair, 'RECIPIENT_ADDRESS');

Success! Understanding What Happened

You’ve successfully submitted a transaction via Sender! Here’s what made it work:

No credits consumed: Sender is free for all users
Dual routing: Your transaction was sent to both validators and Jito simultaneously
Required tip: The 0.001 SOL tip enables Jito’s auction participation
Priority fee: Signals validators your willingness to pay for priority processing
Skipped preflight: Optimizes for speed over validation

What’s Next? The code above works, but you can optimize further with dynamic fees, automatic compute unit calculation, and retry logic. Check out the Simple Code Example and Advanced Example with Dynamic Optimization below for production-ready implementations with detailed explanations.

Routing Options

Default Dual Routing

Sends transactions to both Solana validators and Jito infrastructure simultaneously for maximum inclusion probability. Requires minimum 0.001 SOL tip.

SWQOS-Only Alternative

For cost-optimized trading, add ?swqos_only=true to any endpoint URL. Routes exclusively through SWQOS infrastructure with a lower 0.0005 SOL minimum tip requirement.

Requirements

Mandatory Requirements: All transactions must include tips (0.001 SOL minimum, or 0.0005 SOL for SWQOS-only), priority fees, and skip preflight checks.

1. Skip Preflight (Mandatory)

The skipPreflight parameter must be set to true. Sender is optimized for traders who prioritize speed over transaction validation.

{
  "skipPreflight": true  // Required: must be true
}

Since preflight checks are skipped, ensure your transactions are properly constructed and funded before submission. Invalid transactions will be rejected by the network after submission.

2. Tips and Priority Fees Required

All transactions submitted through Sender must include both tips and priority fees:

Tips: Minimum 0.001 SOL transfer to a designated tip account (or 0.0005 SOL for SWQOS-only)

Designated Tip Accounts (mainnet-beta)

4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE
D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ
9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta
5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn
2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD
2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ
wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF
3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT
4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey
4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or

Priority Fees: Compute unit pricing via ComputeBudgetProgram.setComputeUnitPrice to prioritize your transaction in the validator queue

Why Both Are Required

Tips: Enable access to Jito’s infrastructure and auction-based transaction inclusion
Priority Fees: Signal to validators your willingness to pay for priority processing through Solana’s native prioritization system
Dual Benefit: Tips give you access to Jito’s auction, while priority fees improve your transaction’s priority with validators—together they maximize inclusion probability

Tip and Priority Fee Guidelines

Jito Tips: Minimum 0.001 SOL is mandatory for auction participation. For current best-practice tip sizing, see the Jito tip guidelines. Priority Fees: Use the Helius Priority Fee API for real-time fee recommendations.

Endpoints

Sender endpoints are available in multiple configurations depending on your use case:

Recommended for frontend applications to avoid CORS issues:

https://sender.helius-rpc.com/fast         # Global HTTPS endpoint

The HTTPS endpoint resolves CORS preflight failures that occur with browser-based applications when using the regional HTTP endpoints. This endpoint automatically routes to the nearest location for optimal performance. Use this for all frontend/browser implementations.

Connection Warming

For applications with long periods between transaction submissions, use the ping endpoint to maintain warm connections and reduce cold start latency.

Ping Endpoint Usage

The ping endpoint accepts simple GET requests and returns a basic response to keep connections alive:

# Frontend applications - use HTTPS (auto-routes to nearest location)
curl https://sender.helius-rpc.com/ping

# Backend applications - use regional HTTP
curl http://slc-sender.helius-rpc.com/ping

// Keep connection warm during idle periods
async function warmConnection(endpoint: string) {
  try {
    const response = await fetch(`${endpoint}/ping`);
    console.log('Connection warmed:', response.ok);
  } catch (error) {
    console.warn('Failed to warm connection:', error);
  }
}

// Frontend applications - use HTTPS endpoint
setInterval(() => {
  warmConnection('https://sender.helius-rpc.com');
}, 30000);

// Backend/server applications - use regional HTTP endpoint
setInterval(() => {
  warmConnection('http://slc-sender.helius-rpc.com');
}, 30000);

Use connection warming when your application has gaps longer than 1 minute between transactions to maintain optimal submission latency.

Usage

The Sender endpoint uses the same sendTransaction method as standard RPC endpoints but with specific requirements for optimal performance. All transactions must include both tips and priority fees, plus skip preflight checks.

Basic Request Format

{
  "id": "unique-request-id",
  "jsonrpc": "2.0", 
  "method": "sendTransaction",
  "params": [
    "BASE64_ENCODED_TRANSACTION", // Must include both tip and priority fee instructions
    {
      "encoding": "base64",
      "skipPreflight": true,       // Required: must be true
      "maxRetries": 0
    }
  ]
}

The BASE64_ENCODED_TRANSACTION above must contain both a SOL transfer instruction with minimum tip to designated tip accounts AND a compute unit price instruction. Without both requirements, your transaction will be rejected.

Simple Code Example

import { 
  Connection, 
  TransactionMessage,
  VersionedTransaction,
  SystemProgram, 
  PublicKey,
  Keypair,
  LAMPORTS_PER_SOL,
  ComputeBudgetProgram
} from '@solana/web3.js';
import bs58 from 'bs58';

const PRIV_B58 = 'Your Private Key';
const RECIPIENT = 'Random Recipient';
const HELIUS_API_KEY = 'Your API Key';
const TIP_ACCOUNTS = [
  "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
  "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ", 
  "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
  "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
  "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
  "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
  "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
  "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
  "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
  "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
];

async function sendWithSender(
  keypair: Keypair, 
  recipientAddress: string
): Promise<string> {
  const connection = new Connection(
    `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`
  );
  
  const { value: { blockhash } } = await connection.getLatestBlockhashAndContext('confirmed');
  
  // Build transaction with tip transfer and transfer to recipient
  const transaction = new VersionedTransaction(
    new TransactionMessage({
      instructions: [
        ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }),
        ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }),
        SystemProgram.transfer({
          fromPubkey: keypair.publicKey,
          toPubkey: new PublicKey(recipientAddress),
          lamports: 0.001 * LAMPORTS_PER_SOL,
        }),
        SystemProgram.transfer({
          fromPubkey: keypair.publicKey,
          toPubkey: new PublicKey(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
          lamports: 0.001 * LAMPORTS_PER_SOL,
        })
      ],
      payerKey: keypair.publicKey,
      recentBlockhash: blockhash,
    }).compileToV0Message()
  );

  // Sign transaction
  transaction.sign([keypair]);
  console.log('Sending transaction via Sender endpoint...');

  // Frontend: Use HTTPS endpoint to avoid CORS issues
  const SENDER_ENDPOINT = 'https://sender.helius-rpc.com/fast'; 
  // Backend: Use regional HTTP endpoint closest to your servers
  // const SENDER_ENDPOINT = 'http://slc-sender.helius-rpc.com/fast';
  const response = await fetch(SENDER_ENDPOINT, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: Date.now().toString(),
      method: 'sendTransaction',
      params: [
        Buffer.from(transaction.serialize()).toString('base64'),
        {
          encoding: 'base64',
          skipPreflight: true, // Required for Sender
          maxRetries: 0
        }
      ]
    })
  });
  const json = await response.json();
  if (json.error) {
    throw new Error(json.error.message);
  }
  const signature = json.result;
  console.log('Transaction sent:', signature);
  
  // Confirmation check
  for (let i = 0; i < 30; i++) {
    const status = await connection.getSignatureStatuses([signature]);
    console.log('Status:', status?.value[0]?.confirmationStatus || 'pending');
    
    if (status?.value[0]?.confirmationStatus === "confirmed") {
      console.log('Transaction confirmed!');
      return signature;
    }
    
    await new Promise(resolve => setTimeout(resolve, 500));
  }
  
  console.log('Transaction may have succeeded but confirmation timed out');
  return signature;
}

// Send transaction
sendWithSender(Keypair.fromSecretKey(bs58.decode(PRIV_B58)), RECIPIENT);

Advanced Example with Dynamic Optimization

The advanced example improves on the simple version with dynamic Jito tips (75th percentile), automatic compute unit calculation, dynamic priority fees, and retry logic.

import { 
Connection, 
TransactionMessage,
VersionedTransaction,
SystemProgram, 
PublicKey,
Keypair,
LAMPORTS_PER_SOL,
ComputeBudgetProgram,
TransactionInstruction
} from '@solana/web3.js';
import bs58 from 'bs58';

const TIP_ACCOUNTS = [
"4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
"D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ", 
"9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
"5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
"2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
"2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
"wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
"3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
"4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
"4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
];

async function getDynamicTipAmount(): Promise<number> {
try {
const response = await fetch('https://bundles.jito.wtf/api/v1/bundles/tip_floor');
const data = await response.json();

if (data && data[0] && typeof data[0].landed_tips_75th_percentile === 'number') {
  const tip75th = data[0].landed_tips_75th_percentile;
  // Use 75th percentile but minimum 0.001 SOL
  return Math.max(tip75th, 0.001);
}

// Fallback if API fails or data is invalid
return 0.001;
} catch (error) {
console.warn('Failed to fetch dynamic tip amount, using fallback:', error);
return 0.001; // Fallback to minimum
}
}

async function sendWithSender(
keypair: Keypair, 
instructions: TransactionInstruction[]
): Promise<string> {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY');

// Validate user hasn't included compute budget instructions
const hasComputeBudget = instructions.some(ix => 
ix.programId.equals(ComputeBudgetProgram.programId)
);
if (hasComputeBudget) {
throw new Error('Do not include compute budget instructions - they are added automatically');
}

// Create copy of instructions to avoid modifying the original array
const allInstructions = [...instructions];

// Get dynamic tip amount from Jito API (75th percentile, minimum 0.001 SOL)
const tipAmountSOL = await getDynamicTipAmount();
const tipAccount = new PublicKey(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]);

console.log(`Using dynamic tip amount: ${tipAmountSOL} SOL`);

allInstructions.push(
SystemProgram.transfer({
  fromPubkey: keypair.publicKey,
  toPubkey: tipAccount,
  lamports: tipAmountSOL * LAMPORTS_PER_SOL,
})
);

// Get recent blockhash with context (Helius best practice)
const { value: blockhashInfo } = await connection.getLatestBlockhashAndContext('confirmed');
const { blockhash, lastValidBlockHeight } = blockhashInfo;

// Simulate transaction to get compute units
const testInstructions = [
ComputeBudgetProgram.setComputeUnitLimit({ units: 1_400_000 }),
...allInstructions,
];

const testTransaction = new VersionedTransaction(
new TransactionMessage({
  instructions: testInstructions,
  payerKey: keypair.publicKey,
  recentBlockhash: blockhash,
}).compileToV0Message()
);
testTransaction.sign([keypair]);

const simulation = await connection.simulateTransaction(testTransaction, {
replaceRecentBlockhash: true,
sigVerify: false,
});

if (!simulation.value.unitsConsumed) {
throw new Error('Simulation failed to return compute units');
}

// Set compute unit limit with minimum 1000 CUs and 10% margin (Helius best practice)
const units = simulation.value.unitsConsumed;
const computeUnits = units < 1000 ? 1000 : Math.ceil(units * 1.1);

// Get dynamic priority fee from Helius Priority Fee API
const priorityFee = await getPriorityFee(
connection, 
allInstructions, 
keypair.publicKey, 
blockhash
);

// Add compute budget instructions at the BEGINNING (must be first)
allInstructions.unshift(
ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee })
);
allInstructions.unshift(
ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnits })
);

// Build final optimized transaction
const transaction = new VersionedTransaction(
new TransactionMessage({
  instructions: allInstructions,
  payerKey: keypair.publicKey,
  recentBlockhash: blockhash,
}).compileToV0Message()
);
transaction.sign([keypair]);

// Send via Sender endpoint with retry logic
return await sendWithRetry(transaction, connection, lastValidBlockHeight);
}

async function getPriorityFee(
connection: Connection, 
instructions: TransactionInstruction[], 
payerKey: PublicKey, 
blockhash: string
): Promise<number> {
try {
const tempTx = new VersionedTransaction(
  new TransactionMessage({
    instructions,
    payerKey,
    recentBlockhash: blockhash,
  }).compileToV0Message()
);

const response = await fetch(connection.rpcEndpoint, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: "1",
    method: "getPriorityFeeEstimate",
    params: [{
      transaction: bs58.encode(tempTx.serialize()),
      options: { recommended: true },
    }],   
  }),
});

const data = await response.json();
return data.result?.priorityFeeEstimate ? 
  Math.ceil(data.result.priorityFeeEstimate * 1.2) : 50_000;
} catch {
return 50_000; // Fallback fee
}
}

async function sendWithRetry(
transaction: VersionedTransaction,
connection: Connection,
lastValidBlockHeight: number
): Promise<string> {
const maxRetries = 3;
// Frontend: Use HTTPS endpoint to avoid CORS issues
const endpoint = 'https://sender.helius-rpc.com/fast';
// Backend: Use regional HTTP endpoint closest to your servers
// const endpoint = 'http://slc-sender.helius-rpc.com/fast';

for (let attempt = 0; attempt < maxRetries; attempt++) {
try {
  // Check blockhash validity
  const currentHeight = await connection.getBlockHeight('confirmed');
  if (currentHeight > lastValidBlockHeight) {
    throw new Error('Blockhash expired');
  }
  
  // Send transaction via Sender endpoint
  const response = await fetch(endpoint, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: Date.now().toString(),
      method: "sendTransaction",
      params: [
        Buffer.from(transaction.serialize()).toString('base64'),
        {
          encoding: "base64",
          skipPreflight: true,    // Required for Sender
          maxRetries: 0           // Implement your own retry logic
        }
      ]
    })
  });
  
  const result = await response.json();
  if (result.error) throw new Error(result.error.message);
  
  console.log(`Transaction sent: ${result.result}`);
  return await confirmTransaction(result.result, connection);
  
} catch (error) {
  console.warn(`Attempt ${attempt + 1} failed:`, error);
  if (attempt === maxRetries - 1) throw error;
  await new Promise(resolve => setTimeout(resolve, 2000));
}
}

throw new Error('All retry attempts failed');
}

async function confirmTransaction(
signature: string, 
connection: Connection
): Promise<string> {
const timeout = 15000;
const interval = 3000;
const startTime = Date.now();

while (Date.now() - startTime < timeout) {
try {
  const status = await connection.getSignatureStatuses([signature]);
  if (status?.value[0]?.confirmationStatus === "confirmed") {
    return signature;
  }
} catch (error) {
  console.warn('Status check failed:', error);
}
await new Promise(resolve => setTimeout(resolve, interval));
}

throw new Error(`Transaction confirmation timeout: ${signature}`);
}

// Example usage following standard Helius docs pattern
export async function exampleUsage() {
const keypair = Keypair.fromSecretKey(new Uint8Array([/* your secret key */]));

// 1. Prepare your transaction instructions (USER ADDS THEIR INSTRUCTIONS HERE)
const instructions: TransactionInstruction[] = [
SystemProgram.transfer({
  fromPubkey: keypair.publicKey,
  toPubkey: new PublicKey("RECIPIENT_ADDRESS"),
  lamports: 0.1 * LAMPORTS_PER_SOL,
}),
// Add more instructions as needed
];

// 2. Send with Sender (automatically adds tip + optimizations)
try {
const signature = await sendWithSender(keypair, instructions);
console.log(`Successful transaction: ${signature}`);
} catch (error) {
console.error('Transaction failed:', error);
}
}

export { sendWithSender };

Best Practices

Endpoint Selection

Frontend Applications: Use https://sender.helius-rpc.com/fast to avoid CORS preflight failures. This endpoint automatically routes to the nearest location for optimal performance.
Backend Applications: Choose the regional HTTP endpoint closest to your infrastructure for optimal performance

Connection Warming

Use the /ping endpoint during idle periods longer than 1 minute
Implement periodic ping calls (every 30-60 seconds) to maintain warm connections
Warm connections before high-frequency trading sessions begin

Transaction Setup

Use skipPreflight: true and maxRetries: 0
Implement your own retry logic
Include minimum 0.001 SOL tip to designated accounts
Fetch blockhash with 'confirmed' commitment
Set appropriate compute unit limits

Rate Limits and Scaling

Default Rate Limit: 6 transactions per second
No Credit Usage: Sender transactions don’t consume API credits from your plan

Support and Scaling

For production deployments requiring higher throughput:

Create a Support Ticket: Include your expected TPS and use case details
Provide Metrics: Share your current transaction patterns

Contact support through the Helius Dashboard or join our Discord community.

Get Started

Solana RPC Nodes

Data Streaming & Event Listening

How to Send Transactions

Getting Data

Dedicated Nodes

Compression

Staking

Billing

Resources

​Overview

Dual Routing

Global Endpoints

No Credits

High Throughput

​Quick Start Guide

Create Your Free Helius Account

Get Your API Key

Send Your First Transaction

Success! Understanding What Happened

​Routing Options

Default Dual Routing

SWQOS-Only Alternative

​Requirements

​1. Skip Preflight (Mandatory)

​2. Tips and Priority Fees Required

​Why Both Are Required

​Tip and Priority Fee Guidelines

​Endpoints

​Connection Warming

​Ping Endpoint Usage

​Usage

​Basic Request Format

​Simple Code Example

​Advanced Example with Dynamic Optimization

​Best Practices

​Endpoint Selection

​Connection Warming

​Transaction Setup

​Rate Limits and Scaling

​Support and Scaling

Overview

Quick Start Guide

Routing Options

Requirements

1. Skip Preflight (Mandatory)

2. Tips and Priority Fees Required

Why Both Are Required

Tip and Priority Fee Guidelines

Endpoints

Connection Warming

Ping Endpoint Usage

Usage

Basic Request Format

Simple Code Example

Advanced Example with Dynamic Optimization

Best Practices

Endpoint Selection

Connection Warming

Transaction Setup

Rate Limits and Scaling

Support and Scaling