Quicknode

March 19, 2025 — 5 min read

With Solana's high throughput and short block times, milliseconds matter. The difference between a successful and failed transaction—or capturing versus missing market opportunities—often comes down to how quickly and efficiently your transactions reach validators.

Quicknode offers multiple specialized strategies for submitting Solana transactions, tailored to different developer needs—from the Core RPC API to enterprise-grade Stake-Weighted Quality of Service (SWQoS). The key to consistently successful transactions lies in choosing the right routing strategy for your use case while optimizing priority fees and compute units. Every component must work in sync to push transactions through efficiently and give you a competitive edge.

In this blog, we'll break down the sendTransaction strategies available on Quicknode and help you determine the best approach for your use case. For details on optimizing your transactions, check out this documentation.

Let’s dive in.

Understanding Solana Transaction Routing: The Basics

At its core, the Solana sendTransaction RPC method submits signed transactions to the network for processing. However, the path your transaction takes significantly impacts its confirmation speed and success rate. Quicknode handles the complexity of this routing by default but also offers advanced tools and add-ons that give you control over how your transactions reach the network.

Quicknode's sendTransaction Options Compared

Quicknode offers four distinct ways to route your Solana transactions, each with unique characteristics and advantages, and all can be implemented with no change to your code.

const connection = new Connection('YOUR_QUICKNODE_ENDPOINT');
const txid = await connection.sendTransaction(transaction);

At a Glance:

*When the slot leader is a Jito client, transactions are sent directly to the validator. When another client is the leader, transactions will be sent to the next leader that is running the Jito Client.

Let’s take a closer look at each ⬇️

1. Core API sendTransaction (SWQoS*)

The standard sendTransaction RPC method available through our Core API, provides reliable transaction submission through Quicknode's globally distributed infrastructure. This option leverages our optimized node architecture to propagate your transaction to the Solana network efficiently.

*Stake-Weighted Quality of Service (SWQoS) is utilized when transaction best practices are followed, as outlined in Quicknode’s Solana transaction guidelines.

Best for: General-purpose applications, development environments, and standard DApp operations where consistent, reliable performance is needed without specialized requirements.

Documentation: sendTransaction

2. JITO Add-on sendTransaction

Die Lil’ JIT Marketplace add-on offers a direct proxy to the Solana sendTransaction RPC method that forwards your transaction directly to the next Jito validator leader. By default, it submits the transaction with MEV protection.

Transactions are prioritized by a tip (a minimum tip of 1,000 lamports), and transactions can be bundled together for sequential, atomic processing.

Best for: Applications requiring improved transaction success rates, complex transaction bundling, and the ability to adapt to market-driven tip economics. Ideal for use cases where execution certainty justifies flexible spending on variable tip rates (e.g., arbitrage) and when you need to send up to 5 transactions to be executed sequentially/atomically (a bundle).

Documentation: sendBundle, sendTransaction

Guide: What are Jito Bundles and How to Use Them?

3. MEV Protection sendTransaction

Our MEV Protection add-ons (Merkle) specifically target protection against Maximal Extractable Value exploitation. These add-ons route your transactions through protected channels that shield them from front-running and sandwich attacks.

Best for: DeFi applications, trading platforms, and any system where transaction ordering protection is critical for preserving user value.

Marketplace Add-on: Solana MEV Protection & Recovery

Guide: What is MEV (Maximum Extractable Value) and How to Protect Your Transactions on Solana

4. Transaction Supercharger (SWQoS)

Our enterprise-grade Transaction Supercharger add-on leverages Stake-Weighted Quality of Service (SWQoS) to provide the highest possible transaction inclusion rates and lowest latency available on Solana by using dedicated staked connections. By routing transactions through our specialized network of high-stake validators, we deliver premium performance for mission-critical operations.

Best for: High-frequency trading, institutional finance applications, and enterprise systems where transaction certainty and minimal latency are non-negotiable requirements.

Contact our team to learn more about Transaction Supercharger

Choosing the Right sendTransaction Method

When selecting a transaction submission strategy, consider these factors:

1. Application Criticality: How important is guaranteed execution for your use case?

2. Timing Sensitivity: Does your application require the absolute lowest latency?

3. MEV Concerns: Are your transactions susceptible to front-running or sandwich attacks?

4. Budget Considerations: What performance improvements justify additional investment?

For most developers, our Core API provides excellent performance for standard applications. As your needs grow more specialized—particularly for financial applications, trading platforms, or high-value transactions—our advanced options deliver performance advantages that directly impact your bottom line.

Getting Started with Advanced Transaction Routing

Ready to optimize your Solana transactions? Here's how to get started:

1. Core API: Available immediately with any Quicknode plan (Sign up free here).

2. LIL’ JIT: Enable through the Quicknode Marketplace or your Quicknode dashboard.

3. MEV Protection: Add via Marketplace (Solana MEV Protection & Recovery) or your Quicknode dashboard.

4. Transaction Supercharger: Contact our enterprise team for qualification and setup.

Once your add-on is enabled, your endpoint will now route sendTransaction requests based on the option you selected. These routing methods operate independently and cannot be activated simultaneously on the same endpoint - you'll need to choose which approach best suits your specific use case. If your use case requires multiple routing methods, consider setting up separate endpoints for each approach. That’s it. Don’t forget to do everything on your client-side to improve transaction landing performance–check out our documentation for how to optimize compute and priority fees.

Scale with Quicknode

As Solana continues to scale, transaction optimization will become increasingly important for developers building competitive applications. Quicknode's multi-tiered approach to transaction routing gives you the flexibility to choose the right performance level for your specific requirements—from standard applications to mission-critical trading systems.

With Transaction Supercharger leading our suite of sendTransaction options, Quicknode continues to deliver infrastructure innovations that keep your applications performing at their best, even as network conditions evolve.

Ready to supercharge your Solana transactions? Log in to your Quicknode dashboard to explore our sendTransaction options further, or contact our enterprise team to learn more about Transaction Supercharger.