> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Helius Sender: Ultra-Low Latency Solana Transaction Submission

> Ultra-low latency Solana transaction submission with dual routing to validators and Jito infrastructure. No credits consumed, global endpoints, optimized for high-frequency trading.

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

<CardGroup cols={2}>
  <Card title="Dual Routing" icon="route">
    Sends to both validators and Jito for optimal speed
  </Card>

  <Card title="Global Endpoints" icon="globe">
    HTTPS endpoint auto-routes to nearest location for frontends, regional HTTP for backends
  </Card>

  <Card title="No Credits" icon="coins">
    Available on all plans without consuming API credits
  </Card>

  <Card title="50 TPS (Default)" icon="gauge-high" href="https://www.helius.dev/contact">
    Need more? Request higher limits and custom tip arrangements
  </Card>
</CardGroup>

## Quickstart 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.

<Steps titleSize="h3">
  <Step title="Create Your Free Helius Account">
    Start by creating your free account at the [Helius Dashboard](https://dashboard.helius.dev/dashboard). Sender is available on all plans, including the free tier, and doesn't consume any API credits.
  </Step>

  <Step title="Get Your API Key">
    Go to the [API Keys](https://dashboard.helius.dev/api-keys) section and copy your key. Use this for getting blockhashes and transaction confirmation. Sender will handle transaction submission.
  </Step>

  <Step title="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.

    <Tabs>
      <Tab title="@solana/web3.js">
        ```typescript [expandable] theme={"system"}
        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.0002 * 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');
        ```
      </Tab>

      <Tab title="@solana/kit">
        ```typescript [expandable] theme={"system"}
        import { pipe } from "@solana/kit";
        import {
          createSolanaRpc,
          createTransactionMessage,
          setTransactionMessageFeePayerSigner,
          setTransactionMessageLifetimeUsingBlockhash,
          appendTransactionMessageInstruction,
          signTransactionMessageWithSigners,
          lamports,
          getBase64EncodedWireTransaction,
          createKeyPairSignerFromBytes,
          address,
        } from "@solana/kit";
        import { getTransferSolInstruction } from "@solana-program/system";
        import {
          getSetComputeUnitLimitInstruction,
          getSetComputeUnitPriceInstruction,
        } from "@solana-program/compute-budget";
        import bs58 from 'bs58';

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

        async function sendWithSender(
          privateKeyB58: string, 
          recipientAddress: string
        ): Promise<string> {
          // Load signer from base58 private key
          const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(privateKeyB58));

          // Init RPC and fetch blockhash
          const rpc = createSolanaRpc('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY');
          const { value: blockhash } = await rpc.getLatestBlockhash().send();

          // Build + sign transaction
          const tx = pipe(
            createTransactionMessage({ version: 0 }),
            (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
            (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
            (m) => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 100_000 }), m),
            (m) => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: 200_000 }), m),
            (m) =>
              appendTransactionMessageInstruction(
                getTransferSolInstruction({
                  source: ownerSigner,
                  destination: address(recipientAddress),
                  amount: lamports(1_000_000n), // 0.001 SOL
                }),
                m
              ),
            (m) =>
              appendTransactionMessageInstruction(
                getTransferSolInstruction({
                  source: ownerSigner,
                  destination: address(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
                  amount: lamports(200_000n), // 0.0002 SOL
                }),
                m
              )
          );

          const signedTx = await signTransactionMessageWithSigners(tx);
          const base64Tx = getBase64EncodedWireTransaction(signedTx);

          console.log('Sending transaction via Sender endpoint...');

          // Send via Sender
          const res = 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: [
                base64Tx,
                { encoding: "base64", skipPreflight: true, maxRetries: 0 },
              ],
            }),
          });

          const { result: sig, error } = await res.json();
          if (error) throw new Error(error.message);

          console.log("Transaction sent: ", sig);
          return sig;
        }

        // Usage
        sendWithSender('YOUR_PRIVATE_KEY', 'RECIPIENT_ADDRESS');
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="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 validators and Jito simultaneously
    * Required tip: The 0.0002 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
  </Step>
</Steps>

**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](#simple-code-example) and [Advanced Example with Dynamic Optimization](#advanced-example-with-dynamic-optimization) below for production-ready implementations with detailed explanations.

## Routing Options

<CardGroup cols={2}>
  <Card title="Default Dual Routing" icon="arrows-split-up-and-left">
    Sends transactions to both Solana validators and Jito infrastructure simultaneously for maximum inclusion probability. Requires minimum 0.0002 SOL tip.
  </Card>

  <Card title="SWQOS-Only Alternative" icon="dollar-sign">
    For cost-optimized trading, add `?swqos_only=true` to any endpoint URL. Routes exclusively through SWQOS infrastructure with a lower 0.000005 SOL minimum tip requirement.
  </Card>
</CardGroup>

## Requirements

<Warning>
  **Mandatory Requirements**: All transactions must include tips (0.0002 SOL minimum, or 0.000005 SOL for SWQOS-only), priority fees, and skip preflight checks.
</Warning>

### 1. Skip Preflight (Mandatory)

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

```typescript theme={"system"}
{
  "skipPreflight": true  // Required: must be true
}
```

<Warning>
  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.
</Warning>

### 2. Tips and Priority Fees Required

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

* **Tips**: Minimum 0.0002 SOL transfer to a designated tip account (or 0.000005 SOL for SWQOS-only)

<Accordion title="Designated Tip Accounts (mainnet-beta)">
  ```text theme={"system"}
  4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE
  D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ
  9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta
  5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn
  2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD
  2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ
  wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF
  3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT
  4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey
  4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or
  ```
</Accordion>

* **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.0002 SOL is mandatory for auction participation. For current best-practice tip sizing, see the [Jito tip guidelines](https://docs.jito.wtf/lowlatencytxnsend/#tips).

**Priority Fees**: Use the [Helius Priority Fee API](/priority-fee-api) for real-time fee recommendations.

## Endpoints

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

<Tabs>
  <Tab title="Frontend/Browser Applications">
    **Recommended for frontend applications to avoid CORS issues:**

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

    <Note>
      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 frontend/browser use cases.
    </Note>
  </Tab>

  <Tab title="Backend/Server Applications">
    **Regional HTTP endpoints for optimal server-to-server latency:**

    ```
    http://slc-sender.helius-rpc.com/fast      # Salt Lake City
    http://ewr-sender.helius-rpc.com/fast      # Newark
    http://lon-sender.helius-rpc.com/fast      # London  
    http://fra-sender.helius-rpc.com/fast      # Frankfurt
    http://ams-sender.helius-rpc.com/fast      # Amsterdam
    http://sg-sender.helius-rpc.com/fast       # Singapore
    http://tyo-sender.helius-rpc.com/fast      # Tokyo
    ```

    <Note>
      For backend/server applications, choose the regional HTTP endpoint closest to your infrastructure for optimal performance.
    </Note>
  </Tab>

  <Tab title="Connection Warming">
    **HTTPS (Frontend):**

    ```
    https://sender.helius-rpc.com/ping         # Global HTTPS ping (auto-routes to nearest location)
    ```

    **HTTP (Backend):**

    ```
    http://slc-sender.helius-rpc.com/ping      # Salt Lake City
    http://ewr-sender.helius-rpc.com/ping      # Newark
    http://lon-sender.helius-rpc.com/ping      # London  
    http://fra-sender.helius-rpc.com/ping      # Frankfurt
    http://ams-sender.helius-rpc.com/ping      # Amsterdam
    http://sg-sender.helius-rpc.com/ping       # Singapore
    http://tyo-sender.helius-rpc.com/ping      # Tokyo
    ```
  </Tab>
</Tabs>

## 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:

```bash theme={"system"}
# 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
```

```typescript theme={"system"}
// 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');
}, 5000);

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

<Note>
  Use connection warming when your application has gaps longer than 5 seconds between transactions to maintain optimal submission latency.
</Note>

## 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

```typescript theme={"system"}
{
  "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
    }
  ]
}
```

<Warning>
  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.
</Warning>

<Card title="API Reference" icon="code" href="/api-reference/sender/sendtransaction">
  View the complete Sender API reference with request/response schemas and parameters.
</Card>

### Simple Code Example

<Tabs>
  <Tab title="@solana/web3.js">
    ```typescript [expandable] theme={"system"}
    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.0002 * 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);
    ```
  </Tab>

  <Tab title="@solana/kit">
    ```typescript [expandable] theme={"system"}
    import { pipe } from "@solana/kit";
    import {
      createSolanaRpc,
      createTransactionMessage,
      setTransactionMessageFeePayerSigner,
      setTransactionMessageLifetimeUsingBlockhash,
      appendTransactionMessageInstruction,
      signTransactionMessageWithSigners,
      lamports,
      getBase64EncodedWireTransaction,
      createKeyPairSignerFromBytes,
      address,
    } from "@solana/kit";
    import { getTransferSolInstruction } from "@solana-program/system";
    import {
      getSetComputeUnitLimitInstruction,
      getSetComputeUnitPriceInstruction,
    } from "@solana-program/compute-budget";
    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(
      privateKeyB58: string, 
      recipientAddress: string
    ): Promise<string> {
      // Load signer from base58 private key
      const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(privateKeyB58));

      // Init RPC and fetch blockhash
      const rpc = createSolanaRpc(`https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`);
      const { value: blockhash } = await rpc.getLatestBlockhash().send();

      // Build + sign transaction
      const tx = pipe(
        createTransactionMessage({ version: 0 }),
        (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
        (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
        (m) => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 100_000 }), m),
        (m) => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: 200_000 }), m),
        (m) =>
          appendTransactionMessageInstruction(
            getTransferSolInstruction({
              source: ownerSigner,
              destination: address(recipientAddress),
              amount: lamports(1_000_000n), // 0.001 SOL
            }),
            m
          ),
        (m) =>
          appendTransactionMessageInstruction(
            getTransferSolInstruction({
              source: ownerSigner,
              destination: address(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
              amount: lamports(200_000n), // 0.0002 SOL
            }),
            m
          )
      );

      const signedTx = await signTransactionMessageWithSigners(tx);
      const base64Tx = getBase64EncodedWireTransaction(signedTx);

      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';

      // Send via Sender
      const res = await fetch(SENDER_ENDPOINT, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          jsonrpc: "2.0",
          id: Date.now().toString(),
          method: "sendTransaction",
          params: [
            base64Tx,
            { encoding: "base64", skipPreflight: true, maxRetries: 0 },
          ],
        }),
      });

      const { result: signature, error } = await res.json();
      if (error) throw new Error(error.message);

      console.log("Transaction sent: ", signature);
      
      // Confirmation check
      for (let i = 0; i < 30; i++) {
        const status = await rpc.getSignatureStatuses([signature]).send();
        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(PRIV_B58, RECIPIENT);
    ```
  </Tab>
</Tabs>

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

<Tabs>
  <Tab title="@solana/web3.js">
    ```typescript [expandable] theme={"system"}
    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.0002 SOL
      return Math.max(tip75th, 0.0002);
    }

    // Fallback if API fails or data is invalid
    return 0.0002;
    } catch (error) {
    console.warn('Failed to fetch dynamic tip amount, using fallback:', error);
    return 0.0002; // 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.0002 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 };
    ```
  </Tab>

  <Tab title="@solana/kit">
    ```typescript [expandable] theme={"system"}
    import { pipe } from "@solana/kit";
    import {
      createSolanaRpc,
      createTransactionMessage,
      setTransactionMessageFeePayerSigner,
      setTransactionMessageLifetimeUsingBlockhash,
      appendTransactionMessageInstructions,
      signTransactionMessageWithSigners,
      lamports,
      getBase64EncodedWireTransaction,
      createKeyPairSignerFromBytes,
      address,
    } from "@solana/kit";
    import { getTransferSolInstruction } from "@solana-program/system";
    import {
      getSetComputeUnitLimitInstruction,
      getSetComputeUnitPriceInstruction,
    } from "@solana-program/compute-budget";
    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.0002 SOL
          return Math.max(tip75th, 0.0002);
        }
        
        // Fallback if API fails or data is invalid
        return 0.0002;
      } catch (error) {
        console.warn('Failed to fetch dynamic tip amount, using fallback:', error);
        return 0.0002; // Fallback to minimum
      }
    }

    async function sendWithSender(
      privateKeyB58: string, 
      instructionBuilders: Array<(signer: any) => any>
    ): Promise<string> {
      const rpc = createSolanaRpc('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY');
      
      // Load signer from base58 private key
      const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(privateKeyB58));
      
      // Build user instructions
      const userInstructions = instructionBuilders.map(builder => builder(ownerSigner));
      
      // Get dynamic tip amount from Jito API (75th percentile, minimum 0.0002 SOL)
      const tipAmountSOL = await getDynamicTipAmount();
      const tipAccount = TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)];
      
      console.log(`Using dynamic tip amount: ${tipAmountSOL} SOL`);
      
      // Get recent blockhash with context
      const { value: blockhashInfo } = await rpc.getLatestBlockhash().send();
      const { blockhash, lastValidBlockHeight } = blockhashInfo;
      
      // Create tip instruction
      const tipInstruction = getTransferSolInstruction({
        source: ownerSigner,
        destination: address(tipAccount),
        amount: lamports(BigInt(Math.floor(tipAmountSOL * 1_000_000_000))),
      });
      
      // Create transaction message for simulation with max compute units
      const testInstructions = [
        getSetComputeUnitLimitInstruction({ units: 1_400_000 }),
        ...userInstructions,
        tipInstruction
      ];
      
      const testTx = pipe(
        createTransactionMessage({ version: 0 }),
        (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
        (m) => setTransactionMessageLifetimeUsingBlockhash(blockhashInfo, m),
        (m) => appendTransactionMessageInstructions(testInstructions, m)
      );

      // Simulate transaction using RPC directly
      const signedTestTx = await signTransactionMessageWithSigners(testTx);
      const serializedTestTx = getBase64EncodedWireTransaction(signedTestTx);
      
      const simulationResponse = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          jsonrpc: '2.0',
          id: '1',
          method: 'simulateTransaction',
          params: [
            serializedTestTx,
            { encoding: 'base64', commitment: 'processed' }
          ]
        })
      });
      
      const simulation = await simulationResponse.json();
      
      if (simulation.error || !simulation.result?.value?.unitsConsumed) {
        throw new Error('Simulation failed to return compute units');
      }

      // Set compute unit limit with minimum 1000 CUs and 10% margin
      const units = simulation.result.value.unitsConsumed;
      const computeUnits = units < 1000 ? 1000 : Math.ceil(Number(units) * 1.1);
      
      // Get dynamic priority fee
      const priorityFee = await getPriorityFee(rpc, userInstructions, ownerSigner, blockhashInfo);
      
      // Build final optimized transaction
      const finalInstructions = [
        getSetComputeUnitLimitInstruction({ units: computeUnits }),
        getSetComputeUnitPriceInstruction({ microLamports: priorityFee }),
        ...userInstructions,
        tipInstruction
      ];
      
      const tx = pipe(
        createTransactionMessage({ version: 0 }),
        (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
        (m) => setTransactionMessageLifetimeUsingBlockhash(blockhashInfo, m),
        (m) => appendTransactionMessageInstructions(finalInstructions, m)
      );

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

    async function getPriorityFee(
      rpc: any, 
      instructions: any[], 
      payerSigner: any, 
      blockhashInfo: any
    ): Promise<number> {
      try {
        const tempTx = pipe(
          createTransactionMessage({ version: 0 }),
          (m) => setTransactionMessageFeePayerSigner(payerSigner, m),
          (m) => setTransactionMessageLifetimeUsingBlockhash(blockhashInfo, m),
          (m) => appendTransactionMessageInstructions(instructions, m)
        );
        
        const signedTempTx = await signTransactionMessageWithSigners(tempTx);
        const serializedTx = getBase64EncodedWireTransaction(signedTempTx);
        
        const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            jsonrpc: "2.0",
            id: "1",
            method: "getPriorityFeeEstimate",
            params: [{
              transaction: serializedTx,
              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: any,
      rpc: any,
      lastValidBlockHeight: bigint
    ): 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 { value: currentHeight } = await rpc.getBlockHeight('confirmed').send();
        if (currentHeight > lastValidBlockHeight) {
          throw new Error('Blockhash expired');
        }
          
          // Sign and serialize transaction
          const signedTx = await signTransactionMessageWithSigners(transaction);
          const base64Tx = getBase64EncodedWireTransaction(signedTx);
          
          // 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: [
                base64Tx,
                {
                  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, rpc);
          
        } 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, 
      rpc: any
    ): Promise<string> {
      const timeout = 15000;
      const interval = 3000;
      const startTime = Date.now();
      
      while (Date.now() - startTime < timeout) {
        try {
          const status = await rpc.getSignatureStatuses([signature]).send();
          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 privateKeyB58 = 'YOUR_PRIVATE_KEY_BASE58';
      
      // 1. Prepare your transaction instruction builders (USER ADDS THEIR INSTRUCTIONS HERE)
      const instructionBuilders = [
        (signer: any) => getTransferSolInstruction({
          source: signer,
          destination: address("RECIPIENT_ADDRESS"),
          amount: lamports(100_000_000n), // 0.1 SOL
        }),
        // Add more instruction builders as needed
      ];
      
      // 2. Send with Sender (automatically adds tip + optimizations)
      try {
        const signature = await sendWithSender(privateKeyB58, instructionBuilders);
        console.log(`Successful transaction: ${signature}`);
      } catch (error) {
        console.error('Transaction failed:', error);
      }
    }

    export { sendWithSender };
    ```
  </Tab>
</Tabs>

## 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](#endpoints) closest to your infrastructure for optimal performance

### Connection Warming

* Use the `/ping` endpoint during idle periods longer than 5 seconds
* Implement periodic ping calls (every 5 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.0002 SOL tip to designated accounts
* Fetch blockhash with `'confirmed'` commitment
* Set appropriate compute unit limits

## Rate Limits and Scaling

* **Default Rate Limit**: 50 transactions per second
* **No Credit Usage**: Sender transactions don't consume API credits from your plan
* **Professional Plan Upgrades**: Professional plan users can request significant rate limit increases to support high-throughput trading applications

### Custom TPS with API Key Authentication

<Note>
  This section is only relevant if you have been granted increased TPS limits and received an API key from the Helius team. Standard users can skip this section.
</Note>

If you have been approved for higher TPS limits, you will receive a dedicated API key for Sender. To use it, append the API key as a query parameter to your endpoint URL:

<Tabs>
  <Tab title="Frontend/Browser Applications">
    ```
    https://sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    ```
  </Tab>

  <Tab title="Backend/Server Applications">
    ```
    http://slc-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://ewr-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://lon-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://fra-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://ams-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://sg-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://tyo-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    ```
  </Tab>
</Tabs>

**Example Usage:**

```typescript theme={"system"}
const SENDER_ENDPOINT = 'https://sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY';

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: [
      base64Transaction,
      { encoding: 'base64', skipPreflight: true, maxRetries: 0 }
    ]
  })
});
```

<Tip>
  Need more than 50 TPS or a custom plan? [Request higher limits](https://www.helius.dev/contact) and explore custom tip arrangements for Sender by contacting our sales team.
</Tip>

## Support

Get support through the [Helius Dashboard](https://dashboard.helius.dev) or join [Discord](https://discord.com/invite/6GXdee3gBj) for assistance.

## See Also: Shred Delivery

Want to receive the earliest onchain signals?

[Raw Shreds (UDP)](/shred-delivery/raw-shreds) is our specialized delivery of raw Solana shreds via UDP, built to give you the earliest possible access to Solana’s raw transaction data.

By delivering unprocessed shreds directly from the network, Shred Delivery provides a competitive edge for HFTs, arbitragers, searchers, and other latency-sensitive traders.

<Tip>
  Start receiving raw shreds. [Subscribe to Helius Shred Delivery](https://dashboard.helius.dev/shred-delivery-seats) in your dashboard.
</Tip>