> ## 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: envío de transacciones de Solana con latencia ultrabaja

> Envío de transacciones de Solana con latencia ultrabaja y enrutamiento por múltiples rutas. No consume créditos, ofrece endpoints globales y está optimizado para operaciones de alta frecuencia.

## Descripción general

<Note>
  **Actualización de precios:** Sender Max ahora requiere una propina mínima de **0.001 SOL**. Esto
  te incorpora a un búfer de propinas prioritarias para llegar al inicio del bloque; aumenta la propina para entrar primero. El nivel
  [solo SWQOS](/docs/es/sending-transactions/sender-swqos-only), optimizado para reducir costos, se mantiene en 0.000005
  SOL.
</Note>

Helius Sender es un servicio especializado en el envío de transacciones con latencia ultrabaja, diseñado para operaciones sensibles a la latencia. Envía tu transacción simultáneamente por todas las rutas (Helius, Jito, Harmonic, Rakurai, etc.) para proporcionarle la ruta más rápida posible hacia un bloque.

Sender **no consume créditos de API**: pagas por transacción con una propina en SOL. Está disponible en todos los planes, incluido el nivel gratuito.

<CardGroup cols={2}>
  <Card title="No Credits" icon="coins">
    Disponible en todos los planes sin consumir créditos de API. Pagas por cada envío con
    una propina en SOL.
  </Card>

  <Card title="Multi-Path Routing" icon="arrows-split-up-and-left">
    Envía por todas las rutas (Helius, Jito, Harmonic, Rakurai, etc.) para lograr la inclusión más rápida posible
  </Card>

  <Card title="Global Endpoints" icon="globe">
    El endpoint HTTPS dirige automáticamente a la ubicación más cercana para aplicaciones frontend y ofrece HTTP
    regional para aplicaciones backend
  </Card>

  <Card title="50 TPS (Default)" icon="gauge-high" href="https://www.helius.dev/contact">
    ¿Necesitas más? Solicita límites más altos y acuerdos de propinas personalizados
  </Card>
</CardGroup>

## Elige tu nivel

Sender ofrece dos niveles. Ambos tienen baja latencia y no consumen créditos. La diferencia radica en la cantidad de rutas que sigue tu transacción y en la propina mínima requerida.

| Nivel                                                    | Enrutamiento                      | Propina mínima | Búfer de propinas | Ideal para                                                                    |
| -------------------------------------------------------- | --------------------------------- | -------------- | ----------------- | ----------------------------------------------------------------------------- |
| [Sender Max](/docs/es/sending-transactions/sender-max)        | Todas las rutas de alta velocidad | 0.001 SOL      | Sí                | Transacciones y paquetes muy disputados que necesitan la inclusión más rápida |
| [Solo SWQOS](/docs/es/sending-transactions/sender-swqos-only) | Una única ruta SWQOS              | 0.000005 SOL   | No                | Operaciones con costos optimizados mediante una ruta rápida                   |

<Note>
  Se aceptan propinas de entre 0.000005 SOL y 0.001 SOL, pero **no** entran en el
  búfer de propinas prioritarias. Se envían según el mejor esfuerzo a través de menos
  rutas. Para obtener prioridad en el búfer y usar todas las rutas de enrutamiento, da una propina de al menos 0.001
  SOL.
</Note>

<CardGroup cols={2}>
  <Card title="Sender Max (fastest landing)" icon="trophy" href="/docs/es/sending-transactions/sender-max">
    Se enruta por todas las rutas y se incorpora a un búfer de propinas prioritarias para los
    envíos más competitivos. Admite tanto transacciones como paquetes.
  </Card>

  <Card title="SWQOS-only (cost-optimized)" icon="dollar-sign" href="/docs/es/sending-transactions/sender-swqos-only">
    La propina más baja mediante una única ruta rápida. Agrega `?swqos_only=true` a cualquier URL de endpoint.
  </Card>
</CardGroup>

## Guía de inicio rápido

¿Todo listo para enviar tu primera transacción de Solana con latencia ultrabaja? Esta guía te ayudará a comenzar en minutos. Lo mejor es que **no necesitas un plan de pago ni acceso especial**: Sender está disponible para todos los usuarios y no consume créditos de API.

El siguiente ejemplo usa el nivel [Sender Max](/docs/es/sending-transactions/sender-max), con una propina de 0.001 SOL. Para usar la opción con la propina más baja, consulta [Solo SWQOS](/docs/es/sending-transactions/sender-swqos-only).

<Steps titleSize="h3">
  <Step title="Create Your Free Helius Account">
    Comienza por crear tu cuenta gratuita en el [panel de Helius](https://dashboard.helius.dev/dashboard). Sender está disponible en todos los planes, incluido el nivel gratuito, y no consume créditos de API.
  </Step>

  <Step title="Get Your API Key">
    Ve a la sección [Claves de API](https://dashboard.helius.dev/api-keys) y copia tu clave. Úsala para obtener hashes de bloque y confirmar transacciones. Sender se encargará del envío de la transacción.
  </Step>

  <Step title="Send Your First Transaction">
    Enviemos una transferencia sencilla de SOL mediante Sender. Este ejemplo incluye la propina y la comisión de prioridad requeridas, y omite la simulación previa para reducir la latencia (opcional).

    <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: 1 * 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, // 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
        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_000_000n), // 1 SOL
                }),
                m
              ),
            (m) =>
              appendTransactionMessageInstruction(
                getTransferSolInstruction({
                  source: ownerSigner,
                  destination: address(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
                  amount: lamports(1_000_000n), // 0.001 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">
    ¡Enviaste correctamente una transacción mediante Sender! Esto es lo que permitió que funcionara:

    * Sin consumo de créditos: Sender no consume créditos para ningún usuario
    * Enrutamiento por múltiples rutas: tu transacción se envió simultáneamente por todas las rutas (Helius, Jito, Harmonic, Rakurai, etc.)
    * Propina requerida: una propina de 0.001 SOL entra en el búfer de propinas prioritarias y usa todas las rutas de enrutamiento. Consulta los [niveles](#elige-tu-nivel) para ver la opción Solo SWQOS con una propina menor
    * Comisión de prioridad: indica a los validadores que estás dispuesto a pagar por el procesamiento prioritario
    * Simulación previa omitida (opcional): cambia la validación por mayor velocidad; Sender también admite comprobaciones previas
  </Step>
</Steps>

## Requisitos

<Warning>
  **Requisitos obligatorios**: Cada transacción de Sender debe incluir una propina
  (mínimo de 0.001 SOL para [Sender Max](/docs/es/sending-transactions/sender-max) o
  0.000005 SOL para [Solo SWQOS](/docs/es/sending-transactions/sender-swqos-only)) y una
  comisión de prioridad.
</Warning>

<Note>
  `skipPreflight` es opcional: Sender admite comprobaciones previas. Configura
  `skipPreflight: true` para cambiar la validación por una menor latencia.
</Note>

### Propinas y comisiones de prioridad

Todas las transacciones enviadas mediante Sender **deben incluir una propina y una comisión de prioridad**:

* **Propina**: una transferencia de SOL a una cuenta de propinas designada. El mínimo es de 0.001 SOL para Sender Max o 0.000005 SOL para Solo SWQOS.
* **Comisión de prioridad**: precio de las unidades de cómputo mediante `ComputeBudgetProgram.setComputeUnitPrice` para priorizar tu transacción en la cola del validador.

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

#### Por qué se requieren ambas

* **Propinas**: te dan acceso a todas las rutas de enrutamiento de Sender (Helius, Jito, Harmonic, Rakurai, etc.) y al búfer de propinas prioritarias
* **Comisiones de prioridad**: indican a los validadores que estás dispuesto a pagar por el procesamiento prioritario mediante el sistema de priorización nativo de Solana
* **En conjunto**: las propinas maximizan las rutas que puede seguir tu transacción, mientras que las comisiones de prioridad mejoran su prioridad ante los validadores. Juntas maximizan la probabilidad de inclusión

Usa la [API de comisiones de prioridad de Helius](/docs/es/priority-fee-api) para obtener recomendaciones de comisiones de prioridad en tiempo real.

## Endpoints

Los endpoints de Sender están disponibles en varias configuraciones según tu caso de uso:

<Tabs>
  <Tab title="Frontend/Browser Applications">
    **Recomendado para aplicaciones frontend a fin de evitar problemas de CORS:**

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

    <Note>
      El endpoint HTTPS resuelve los errores de las solicitudes de comprobación previa de CORS que ocurren en
      las aplicaciones basadas en navegador cuando usan endpoints HTTP regionales. Este
      endpoint dirige automáticamente a la ubicación más cercana para ofrecer un rendimiento
      óptimo. Úsalo para casos de uso de frontend o navegador.
    </Note>
  </Tab>

  <Tab title="Backend/Server Applications">
    **Endpoints HTTP regionales para una latencia óptima entre servidores:**

    ```
    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>
      Para aplicaciones backend o de servidor, elige el endpoint HTTP regional más cercano
      a tu infraestructura para obtener un rendimiento óptimo.
    </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>

## Preparación de conexiones

Para aplicaciones con períodos prolongados entre envíos de transacciones, usa el endpoint de ping para mantener activas las conexiones y reducir la latencia del arranque en frío.

El endpoint de ping acepta solicitudes GET simples y devuelve una respuesta básica para mantener activas las conexiones:

```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>
  Usa la preparación de conexiones cuando tu aplicación tenga intervalos de más de 5 segundos
  entre transacciones para mantener una latencia de envío óptima.
</Note>

## Formato de la solicitud

Sender acepta dos métodos en el mismo endpoint. Cada envío debe incluir una propina y una comisión de prioridad. Omitir la simulación previa es opcional y reduce la latencia.

### sendTransaction

Envía una sola transacción. Debe contener tanto una transferencia de SOL con la propina mínima a una cuenta de propinas designada **como** una instrucción de precio de unidades de cómputo. Si falta alguna de las dos, se rechazará.

```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,       // Optional: skip for lower latency
      "maxRetries": 0
    }
  ]
}
```

Consulta el [inicio rápido](#guía-de-inicio-rápido) para ver un ejemplo completo y ejecutable de `sendTransaction`.

### sendBundle

Envía hasta 4 transacciones completamente firmadas para una ejecución atómica de todo o nada. Al menos una transacción debe incluir la propina.

```typescript theme={"system"}
{
  "id": "unique-request-id",
  "jsonrpc": "2.0",
  "method": "sendBundle",
  "params": [
    ["BASE64_SIGNED_TX_1", "BASE64_SIGNED_TX_2"], // Up to 4; at least one carries the tip
    { "encoding": "base64" }
  ]
}
```

Consulta [paquetes de Sender Max](/docs/es/sending-transactions/sender-max#paquetes) para ver un ejemplo completo y aprender a realizar el seguimiento de la inclusión.

### MEV Protect (opcional)

Para evitar validadores vinculados estadísticamente a ataques sándwich, agrega el parámetro de consulta `mev-protect=true` a la URL del endpoint. Funciona en ambos niveles de Sender y con `sendTransaction` e `sendBundle`, sin modificar el cuerpo de tu solicitud.

```
https://sender.helius-rpc.com/fast?mev-protect=true                    # Sender Max
https://sender.helius-rpc.com/fast?swqos_only=true&mev-protect=true     # SWQOS-only
```

Consulta [MEV Protect](/docs/es/sending-transactions/mev-protect) para saber cómo funciona y conocer sus ventajas y desventajas.

<Card title="API Reference" icon="code" href="/docs/es/api-reference/sender/sendtransaction">
  Consulta la referencia completa de la API de Sender, incluidos los esquemas de solicitud y respuesta y los
  parámetros.
</Card>

## Límites de frecuencia y escalabilidad

* **Límite de frecuencia predeterminado**: 50 transacciones por segundo
* **Sin consumo de créditos**: las transacciones de Sender no consumen créditos de API de tu plan
* **Límites más altos**: los usuarios del plan Professional pueden solicitar aumentos considerables de los límites de frecuencia para admitir aplicaciones de trading de alto rendimiento

### TPS personalizados con autenticación mediante clave de API

<Note>
  Esta sección solo es relevante si te concedieron límites de TPS más altos
  y recibiste una clave de API del equipo de Helius. Los usuarios estándar pueden omitir esta
  sección.
</Note>

Si se aprobaron límites de TPS más altos para ti, recibirás una clave de API exclusiva para Sender. Para usarla, agrega la clave de API como parámetro de consulta a la URL de tu endpoint:

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

<Tip>
  ¿Necesitas más de 50 TPS o un plan personalizado? [Solicita límites más
  altos](https://www.helius.dev/contact) y consulta los acuerdos de propinas personalizados
  para Sender comunicándote con nuestro equipo de ventas.
</Tip>

## Soporte

Obtén soporte mediante el [panel de Helius](https://dashboard.helius.dev) o únete a [Discord](https://discord.com/invite/6GXdee3gBj) para recibir ayuda.

## Consulta también: Shred Delivery

[Shreds sin procesar (UDP)](/docs/es/shred-delivery/raw-shreds) es nuestro servicio especializado de entrega de shreds sin procesar de Solana mediante UDP, diseñado para brindarte acceso con latencia ultrabaja a los datos de transacciones sin procesar de Solana.

Al entregar shreds sin procesar directamente desde la red, Shred Delivery proporciona una ventaja competitiva a propAMM, francotiradores, copy traders, bots de liquidación, operadores de arbitraje y operadores de nodos RPC que quieren eliminar la latencia de sincronización de la red.

<Tip>
  Comienza a recibir shreds sin procesar. [Suscríbete a Helius Shred
  Delivery](https://dashboard.helius.dev/shred-delivery-seats) desde tu panel.
</Tip>