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

# Sender Max: inclusión más rápida de transacciones de Solana

> Envía transacciones y paquetes de Solana mediante el nivel de Helius Sender con la inclusión más rápida: todas las rutas en cada envío, con una propina mínima de 0.001 SOL.

## Descripción general

<Note>
  **Actualización de precios:** Sender Max ahora usa una propina mínima de **0.001 SOL**. Esto
  te permite entrar en un búfer de propinas prioritarias para llegar al inicio del bloque; ofrece una propina mayor para entrar primero.
</Note>

Sender Max es el nivel de mayor rendimiento de [Helius Sender](/docs/es/sending-transactions/sender), diseñado para envíos que deben incluirse antes que los de la competencia. Enruta tu envío por todas las rutas de alta velocidad disponibles y lo introduce en un búfer de propinas prioritarias que favorece las propinas más altas.

Sender Max admite **transacciones individuales y paquetes**. Ambos usan todas las rutas (Helius, Jito, Harmonic, Rakurai, etc.); la única diferencia es la carga útil: envía una transacción con `sendTransaction` o hasta cuatro con `sendBundle`.

Este nivel requiere una propina mínima de **0.001 SOL**. Para optimizar los costos al enviar por una sola ruta, usa en su lugar el nivel [solo SWQOS](/docs/es/sending-transactions/sender-swqos-only).

<CardGroup cols={2}>
  <Card title="Fastest Landing" icon="trophy">
    Se enruta por todas las rutas de alta velocidad para ofrecer la mayor probabilidad de
    inclusión
  </Card>

  <Card title="Priority Tip Buffer" icon="arrow-up-wide-short">
    Tu envío entra en un búfer de propinas prioritarias que da prioridad a los
    envíos con las propinas más altas; ofrece una propina mayor para entrar primero
  </Card>

  <Card title="No Credits" icon="coins">
    Disponible en todos los planes sin consumir créditos de API
  </Card>

  <Card title="0.001 SOL Minimum Tip" icon="dollar-sign">
    La propina mínima necesaria para entrar en el búfer de propinas prioritarias y usar todas las
    rutas
  </Card>
</CardGroup>

## Cómo funciona

Cuando ofreces una propina de al menos **0.001 SOL**, tu envío, ya sea una transacción individual o un paquete, se enruta por todas las rutas de alta velocidad disponibles y entra en un búfer de propinas prioritarias. El búfer favorece las propinas más altas, por lo que aumentar tu propina por encima del mínimo mejora tus probabilidades de entrar primero.

<Note>
  Las propinas inferiores a 0.001 SOL no entran en el búfer de propinas prioritarias; se envían con el mejor esfuerzo posible
  mediante menos rutas. Para obtener envíos predecibles de baja latencia con una propina menor,
  usa el nivel [solo SWQOS](/docs/es/sending-transactions/sender-swqos-only)
  (0.000005 SOL).
</Note>

## Cuándo usar Max

<CardGroup cols={2}>
  <Card title="Good fit" icon="circle-check">
    Cuentas con mucha competencia, lanzamientos competitivos de tokens, liquidaciones y cualquier
    transacción en la que entrar primero justifique una propina mayor.
  </Card>

  <Card title="Consider SWQOS-only instead" icon="dollar-sign" href="/docs/es/sending-transactions/sender-swqos-only">
    Flujos sensibles a los costos o de gran volumen en los que una sola ruta rápida consigue una inclusión confiable.
  </Card>
</CardGroup>

## Requisitos

Cada envío de Sender Max debe incluir:

* **Propina**: una transferencia de al menos **0.001 SOL** a una [cuenta de propinas](/docs/es/sending-transactions/sender#requisitos) designada. En un paquete, al menos una transacción debe incluir la propina.
* **Tarifa de prioridad**: una instrucción de precio por unidad de cómputo con una tarifa de prioridad de al menos **5,000 lamports**. Consulta [Tarifas de prioridad](#tarifas-de-prioridad).

Omitir la simulación previa (`skipPreflight: true`) es opcional, pero se recomienda hacerlo, ya que las comprobaciones previas aumentan la latencia.

<Warning>
  Se rechazarán las transacciones que no incluyan la propina o la tarifa de prioridad. Para consultar
  las reglas específicas de los paquetes, consulta [Paquetes](#paquetes).
</Warning>

## Tarifas de prioridad

Cada transacción debe incluir una tarifa de prioridad de al menos **5,000 lamports**, y recomendamos **al menos 10,000 lamports** para lograr una inclusión más confiable. La propina introduce tu transacción en el búfer de propinas prioritarias, mientras que la tarifa de prioridad aumenta su prioridad en el planificador del validador; juntas maximizan tus probabilidades de inclusión.

Configura una tarifa de prioridad mediante una instrucción de precio por unidad de cómputo. Tu tarifa de prioridad total es el precio por unidad de cómputo (en microlamports) multiplicado por tu límite de unidades de cómputo:

```typescript theme={"system"}
import { ComputeBudgetProgram } from "@solana/web3.js";

ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 });
```

Usa la [API de tarifas de prioridad de Helius](/docs/es/priority-fee-api) para obtener recomendaciones de tarifas en tiempo real basadas en las condiciones actuales de la red.

## Endpoints

Usa el endpoint HTTPS global para los frontends o el endpoint HTTP regional más cercano a tus servidores para los backends.

**Frontend/navegador (HTTPS global):**

```
https://sender.helius-rpc.com/fast
```

**Backend/servidor (HTTP regional):**

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

Consulta la [referencia de endpoints de Sender](/docs/es/sending-transactions/sender#endpoints) para obtener información sobre el calentamiento de conexiones y otros detalles.

<Tip>
  ¿Quieres evitar los validadores vinculados a ataques sándwich? Agrega
  [`mev-protect=true`](/docs/es/sending-transactions/mev-protect) a la URL del endpoint;
  funciona tanto con `sendTransaction` como con `sendBundle`:
  `https://sender.helius-rpc.com/fast?mev-protect=true`.
</Tip>

## Ejemplo de código

<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 = 'Recipient Address';
    const HELIUS_API_KEY = 'Your API Key';
    const TIP_ACCOUNTS = [
      "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
      "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
      "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
      "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
      "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
      "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
      "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
      "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
      "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
      "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
    ];

    async function sendWithSenderMax(
      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: priority fee + recipient transfer + 0.001 SOL tip
      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, // Minimum tip to enter the priority tip buffer
            })
          ],
          payerKey: keypair.publicKey,
          recentBlockhash: blockhash,
        }).compileToV0Message()
      );

      transaction.sign([keypair]);

      // Frontend: use the global HTTPS endpoint to avoid CORS issues
      const SENDER_ENDPOINT = 'https://sender.helius-rpc.com/fast';
      // Backend: use the 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, // Optional: skip for lower latency
              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
    sendWithSenderMax(Keypair.fromSecretKey(bs58.decode(PRIV_B58)), RECIPIENT);
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={"system"}
    curl "https://sender.helius-rpc.com/fast" \
      -X POST \
      -H "Content-Type: application/json" \
      -d '{
        "jsonrpc": "2.0",
        "id": 1,
        "method": "sendTransaction",
        "params": [
          "BASE64_ENCODED_TRANSACTION",
          {
            "encoding": "base64",
            "skipPreflight": true,
            "maxRetries": 0
          }
        ]
      }'
    ```
  </Tab>
</Tabs>

<Tip>
  Para transacciones competitivas, es poco probable que el mínimo de 0.001 SOL sea
  competitivo. Ajusta tu propina para que se acerque al valor de la transacción que
  intentas incluir: cuanto más valiosa sea para ti una inclusión exitosa, mayor
  debe ser tu propina. El mínimo es un límite inferior, no un objetivo.
</Tip>

## Paquetes

Un paquete es simplemente otra carga útil que acepta Sender Max. Envía hasta 4 transacciones completamente firmadas para que se ejecuten de forma atómica (todas o ninguna) y en orden. Entran en el **mismo búfer de propinas prioritarias** que una transacción individual; el búfer da prioridad a los paquetes con las propinas más altas para conseguir la inclusión más rápida.

<Warning>
  **Proporciona únicamente la propina de 0.001 SOL de Sender.** Sender Max enruta tu paquete
  por todas las rutas de alta velocidad y agrega en tu nombre las propinas de cada ruta; no
  agregues una propina de Jito por separado, no uses cuentas de propinas de Jito ni configures el encabezado `jito-region`.
  Estas opciones solo se aplican a los [paquetes
  básicos](/docs/es/sending-transactions/send-bundle).
</Warning>

### Requisitos

* **Hasta 4 transacciones**, completamente firmadas. Se ejecutan de forma secuencial y atómica; si alguna falla, se rechaza todo el paquete.
* **Propina**: al menos una transacción debe transferir como mínimo **0.001 SOL** a una [cuenta de propinas de Sender](/docs/es/sending-transactions/sender#requisitos) designada. Es la misma propina de Sender que se usa para las transacciones individuales. Helius agrega por ti las propinas de cada ruta (incluida Jito), por lo que no debes agregar una propina de Jito por separado.
* **Tarifa de prioridad**: cada transacción debe incluir una [tarifa de prioridad](#tarifas-de-prioridad) de al menos **5,000 lamports**.

### Envío

Envía la solicitud al endpoint de Sender con `method: "sendBundle"`. Usa el endpoint HTTPS global para los frontends o cualquier [endpoint regional](#endpoints) para los backends; todas las regiones de Sender son compatibles.

<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 HELIUS_API_KEY = 'Your API Key';
    const TIP_ACCOUNTS = [
      "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
      "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
      "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
      "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
      "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
      "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
      "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
      "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
      "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
      "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
    ];

    async function sendBundleWithSenderMax(keypair: Keypair): Promise<string[]> {
      const connection = new Connection(
        `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`
      );

      const { value: { blockhash } } = await connection.getLatestBlockhashAndContext('confirmed');

      const tipAccount = new PublicKey(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]);

      // Transaction 1: your instructions + priority fee + the 0.001 SOL Sender tip
      const tx1 = new VersionedTransaction(
        new TransactionMessage({
          instructions: [
            ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }),
            ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }),
            // ... your instructions here ...
            SystemProgram.transfer({
              fromPubkey: keypair.publicKey,
              toPubkey: tipAccount,
              lamports: 0.001 * LAMPORTS_PER_SOL, // Sender tip — only one tx in the bundle needs it
            })
          ],
          payerKey: keypair.publicKey,
          recentBlockhash: blockhash,
        }).compileToV0Message()
      );
      tx1.sign([keypair]);

      // Transaction 2: more instructions — executes after tx1, atomically
      const tx2 = new VersionedTransaction(
        new TransactionMessage({
          instructions: [
            ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }),
            // ... your instructions here ...
          ],
          payerKey: keypair.publicKey,
          recentBlockhash: blockhash,
        }).compileToV0Message()
      );
      tx2.sign([keypair]);

      // Serialize each fully-signed transaction (up to 4) to base64
      const bundle = [tx1, tx2].map((tx) => Buffer.from(tx.serialize()).toString('base64'));

      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: 'sendBundle',
          params: [bundle, { encoding: 'base64' }]
        })
      });

      const json = await response.json();
      if (json.error) {
        throw new Error(json.error.message);
      }

      // Track landing by each transaction's signature (see below)
      const signatures = [tx1, tx2].map((tx) => bs58.encode(tx.signatures[0]));
      console.log('Bundle submitted:', signatures);
      return signatures;
    }

    // Usage
    sendBundleWithSenderMax(Keypair.fromSecretKey(bs58.decode(PRIV_B58)));
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={"system"}
    curl "https://sender.helius-rpc.com/fast" \
      -X POST \
      -H "Content-Type: application/json" \
      -d '{
        "jsonrpc": "2.0",
        "id": 1,
        "method": "sendBundle",
        "params": [
          [
            "BASE64_SIGNED_TX_1",
            "BASE64_SIGNED_TX_2"
          ],
          { "encoding": "base64" }
        ]
      }'
    ```
  </Tab>
</Tabs>

### Seguimiento de la inclusión

Haz el seguimiento de un paquete del mismo modo que el de una transacción individual: espera a que se incluya la firma de cada transacción. Como el paquete es atómico, confirmar una transacción significa que se incluyó todo el paquete. **No** debes usar `getBundleStatuses` ni un identificador de paquete.

Usa el método que mejor se adapte a tu stack:

* Consulta periódicamente [`getSignatureStatuses`](/docs/es/api-reference/rpc/http/getsignaturestatuses) hasta que se confirme la firma.
* Suscríbete a [LaserStream](/docs/es/laserstream) o a [LaserStream WebSocket](/docs/es/rpc/websocket) y espera a que aparezca la firma incluida.
* Usa [Shred Delivery](/docs/es/shred-delivery/raw-shreds) o cualquier otro producto de streaming de Helius que muestre las firmas incluidas.

## Prácticas recomendadas

* **Selección del endpoint**: usa `https://sender.helius-rpc.com/fast` para aplicaciones frontend a fin de evitar problemas de CORS. Para aplicaciones backend, usa el endpoint HTTP regional más cercano a tus servidores.
* **Propinas dinámicas**: aumenta tu propina por encima de 0.001 SOL para transacciones con mucha competencia a fin de mejorar tu prioridad en el búfer de propinas.
* **Calentamiento de conexiones**: usa el [endpoint `/ping`](/docs/es/sending-transactions/sender#preparación-de-conexiones) durante períodos de inactividad superiores a 5 segundos.
* **Tarifas de prioridad**: usa la [API de tarifas de prioridad de Helius](/docs/es/priority-fee-api) para obtener recomendaciones en tiempo real.
* **Reintentos**: configura `maxRetries: 0` e implementa tu propia lógica de reintentos.

## Contenido relacionado

<CardGroup cols={2}>
  <Card title="Sender Overview" icon="rocket" href="/docs/es/sending-transactions/sender">
    Conceptos compartidos: endpoints, calentamiento de conexiones, límites de velocidad y TPS personalizados.
  </Card>

  <Card title="SWQOS-Only Tier" icon="dollar-sign" href="/docs/es/sending-transactions/sender-swqos-only">
    Envíos de baja latencia optimizados para costos mediante una sola ruta (propina mínima de 0.000005 SOL).
  </Card>

  <Card title="MEV Protect" icon="shield-halved" href="/docs/es/sending-transactions/mev-protect">
    Evita los validadores vinculados estadísticamente a ataques sándwich.
  </Card>
</CardGroup>