> ## 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: Envio de Transações Solana com Ultra Baixa Latência

> Envio de transações Solana com ultra baixa latência e roteamento multi-caminho. Sem consumo de créditos, endpoints globais, otimizados para trading de alta frequência.

## Visão Geral

<Note>
  **Atualização de preços:** O Sender Max agora usa um mínimo de **0,001 SOL** como gorjeta. Isso
  coloca você em um buffer de gorjeta prioritária para o topo do bloco — dê mais gorjeta para garantir prioridade. O nível
  [SWQOS-apenas](/docs/pt-BR/sending-transactions/sender-swqos-only) otimizado para custos permanece em 0,000005
  SOL.
</Note>

Helius Sender é um serviço especializado para envio de transações com ultra baixa latência, projetado para trading sensível a latência. Ele envia sua transação por todos os caminhos (Helius, Jito, Harmonic, Rakurai, etc.) simultaneamente para oferecer a rota mais rápida possível para um bloco.

O Sender **não consome créditos de API** — você paga por transação com uma gorjeta em SOL. Está disponível em todos os planos, incluindo o nível gratuito.

<CardGroup cols={2}>
  <Card title="Sem Créditos" icon="coins">
    Disponível em todos os planos sem consumir créditos de API. Você paga por envio com
    uma gorjeta em SOL.
  </Card>

  <Card title="Roteamento Multi-Caminho" icon="arrows-split-up-and-left">
    Envia por todos os caminhos (Helius, Jito, Harmonic, Rakurai, etc.) para inclusão mais rápida possível
  </Card>

  <Card title="Endpoints Globais" icon="globe">
    Endpoint HTTPS roteia automaticamente para a localização mais próxima para frontends, HTTP regional para backends
  </Card>

  <Card title="50 TPS (Padrão)" icon="gauge-high" href="https://www.helius.dev/contact">
    Precisa de mais? Solicite limites mais altos e acordos de gorjeta personalizados
  </Card>
</CardGroup>

## Escolha seu nível

O Sender oferece dois níveis. Ambos são de baixa latência e sem crédito — a diferença é quantos caminhos sua transação percorre e a gorjeta mínima exigida.

| Nível                                                         | Roteamento                           | Gorjeta mínima | Buffer de gorjeta | Ideal para                                                                         |
| ------------------------------------------------------------- | ------------------------------------ | -------------- | ----------------- | ---------------------------------------------------------------------------------- |
| [Sender Max](/docs/pt-BR/sending-transactions/sender-max)          | Todos os caminhos de alta velocidade | 0,001 SOL      | Sim               | Transações altamente disputadas e pacotes que precisam da aterrissagem mais rápida |
| [SWQOS-apenas](/docs/pt-BR/sending-transactions/sender-swqos-only) | Caminho único SWQOS                  | 0,000005 SOL   | Não               | Trading otimizado para custos em um caminho rápido                                 |

<Note>
  Gorjetas entre 0,000005 SOL e 0,001 SOL são aceitas mas **não** entram no
  buffer de gorjeta prioritária — são enviadas na base do melhor esforço por menos
  caminhos. Para obter prioridade de buffer e todos os caminhos de roteamento, gorjeta de pelo menos 0,001
  SOL.
</Note>

<CardGroup cols={2}>
  <Card title="Sender Max (aterrissagem mais rápida)" icon="trophy" href="/docs/pt-BR/sending-transactions/sender-max">
    Roteado por todos os caminhos e inserido em um buffer de gorjeta prioritária para as submissões mais competitivas. Trata tanto de transações quanto de pacotes.
  </Card>

  <Card title="SWQOS-apenas (otimizado para custos)" icon="dollar-sign" href="/docs/pt-BR/sending-transactions/sender-swqos-only">
    Menor gorjeta, caminho único rápido. Adicione `?swqos_only=true` a qualquer URL de endpoint.
  </Card>
</CardGroup>

## Guia de Início Rápido

Pronto para enviar sua primeira transação Solana com ultra baixa latência? Este guia te coloca no caminho em minutos. A melhor parte: **você não precisa de nenhum plano pago ou acesso especial** — o Sender está disponível para todos os usuários e não consome créditos de API.

O exemplo abaixo usa o nível [Sender Max](/docs/pt-BR/sending-transactions/sender-max) (gorjeta de 0,001 SOL). Para a opção de gorjeta mais baixa, veja [SWQOS-apenas](/docs/pt-BR/sending-transactions/sender-swqos-only).

<Steps titleSize="h3">
  <Step title="Crie Sua Conta Gratuita Helius">
    Comece criando sua conta gratuita no [Painel Helius](https://dashboard.helius.dev/dashboard). O Sender está disponível em todos os planos, incluindo o nível gratuito, e não consome nenhum crédito de API.
  </Step>

  <Step title="Obtenha Sua Chave de API">
    Vá para a seção [Chaves de API](https://dashboard.helius.dev/api-keys) e copie sua chave. Use isso para obter hashes de blocos e confirmação de transação. O Sender cuidará do envio da transação.
  </Step>

  <Step title="Envie Sua Primeira Transação">
    Vamos enviar uma transferência simples de SOL usando o Sender. Este exemplo inclui a gorjeta e taxa de prioridade necessárias, e pula a verificação prévia para menor latência (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="Sucesso! Entendendo o que Aconteceu">
    Você enviou com sucesso uma transação via Sender! Aqui está o que fez funcionar:

    * Nenhum crédito consumido: o Sender é gratuito para todos os usuários
    * Roteamento multi-caminho: Sua transação foi enviada por todos os caminhos (Helius, Jito, Harmonic, Rakurai, etc.) simultaneamente
    * Gorjeta necessária: Uma gorjeta de 0,001 SOL entra no buffer de gorjeta prioritária e utiliza todos os caminhos de roteamento. Veja [níveis](#choose-your-tier) para a opção de gorjeta mais baixa SWQOS-apenas
    * Taxa de prioridade: Sinaliza aos validadores sua disposição de pagar por processamento prioritário
    * Verificação prévia pulada (opcional): Troca validação por velocidade — o Sender também suporta verificações prévias
  </Step>
</Steps>

## Requisitos

<Warning>
  **Requisitos obrigatórios**: Toda transação do Sender deve incluir uma gorjeta
  (mínimo de 0,001 SOL para [Sender Max](/docs/pt-BR/sending-transactions/sender-max), ou
  0,000005 SOL para [SWQOS-apenas](/docs/pt-BR/sending-transactions/sender-swqos-only)) e uma
  taxa de prioridade.
</Warning>

<Note>
  `skipPreflight` é opcional — o Sender suporta verificações prévias. Defina
  `skipPreflight: true` para trocar validação por menor latência.
</Note>

### Gorjetas e taxas de prioridade

Todas as transações enviadas através do Sender **devem incluir tanto uma gorjeta quanto uma taxa de prioridade**:

* **Gorjeta**: Uma transferência em SOL para uma conta de gorjeta designada. Mínimo de 0,001 SOL para Sender Max, ou 0,000005 SOL para SWQOS-apenas.
* **Taxa de prioridade**: Preço da unidade de computação via `ComputeBudgetProgram.setComputeUnitPrice` para priorizar sua transação na fila do validador.

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

#### Por que ambos são necessários

* **Gorjetas**: Dão acesso a todos os caminhos de roteamento do Sender (Helius, Jito, Harmonic, Rakurai, etc.) e ao buffer de gorjeta prioritária
* **Taxas de prioridade**: Sinalizam aos validadores sua disposição de pagar por processamento prioritário através do sistema nativo de priorização da Solana
* **Juntos**: Gorjetas maximizam os caminhos que sua transação pode seguir, enquanto as taxas de prioridade melhoram sua prioridade com os validadores — juntos maximizam a probabilidade de inclusão

Use a [API de Taxa de Prioridade Helius](/docs/pt-BR/priority-fee-api) para recomendações de taxa de prioridade em tempo real.

## Endpoints

Os endpoints do Sender estão disponíveis em várias configurações dependendo do seu caso de uso:

<Tabs>
  <Tab title="Aplicações Frontend/Navegador">
    **Recomendado para aplicações frontend para evitar problemas de CORS:**

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

    <Note>
      O endpoint HTTPS resolve falhas de pré-verificação CORS que ocorrem com
      aplicações baseadas em navegadores ao usar os endpoints HTTP regionais. Este
      endpoint roteia automaticamente para a localização mais próxima para desempenho
      otimizado. Use isso para casos de uso frontend/navegador.
    </Note>
  </Tab>

  <Tab title="Aplicações Backend/Servidor">
    **Endpoints HTTP regionais para latência ideal de servidor para servidor:**

    ```
    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 aplicações backend/servidor, escolha o endpoint HTTP regional mais próximo
      da sua infraestrutura para desempenho otimizado.
    </Note>
  </Tab>

  <Tab title="Aquecimento de Conexão">
    **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>

## Aquecimento de Conexão

Para aplicações com longos períodos entre submissões de transações, use o endpoint de ping para manter conexões aquecidas e reduzir a latência de inicialização a frio.

O endpoint de ping aceita solicitações GET simples e retorna uma resposta básica para manter conexões vivas:

```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 o aquecimento de conexão quando sua aplicação tiver intervalos superiores a 5 segundos
  entre transações para manter uma latência de submissão ideal.
</Note>

## Formato de Solicitação

O Sender aceita dois métodos no mesmo endpoint. Toda submissão deve incluir tanto uma gorjeta quanto uma taxa de prioridade; pular a verificação prévia é opcional (diminui a latência).

### sendTransaction

Envie uma única transação. Deve conter tanto uma transferência de SOL com a gorjeta mínima para uma conta de gorjeta designada **quanto** uma instrução de preço de unidade de computação — sem ambos, será rejeitada.

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

Veja o [Início Rápido](#quickstart-guide) para um exemplo completo e executável `sendTransaction`.

### sendBundle

Envie até 4 transações totalmente assinadas para execução atômica, tudo-ou-nada. Pelo menos uma transação deve carregar a gorjeta.

```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" }
  ]
}
```

Veja [Pacotes Sender Max](/docs/pt-BR/sending-transactions/sender-max#bundles) para um exemplo completo e como acompanhar a aterrissagem.

### MEV Protect (opcional)

Para evitar validadores estatisticamente ligados a ataques de sanduíche, adicione o parâmetro de consulta `mev-protect=true` ao URL do endpoint. Funciona nos dois níveis do Sender e tanto em `sendTransaction` quanto em `sendBundle`, sem mudanças no corpo da sua solicitação.

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

Veja [MEV Protect](/docs/pt-BR/sending-transactions/mev-protect) para como funciona e seus tradeoffs.

<Card title="Referência de API" icon="code" href="/docs/pt-BR/api-reference/sender/sendtransaction">
  Veja a referência completa da API Sender com esquemas de solicitação/resposta e
  parâmetros.
</Card>

## Limites de Taxa e Escala

* **Limite de Taxa Padrão**: 50 transações por segundo
* **Sem Uso de Crédito**: Transações do Sender não consomem créditos de API do seu plano
* **Limites Mais Altos**: Usuários do plano profissional podem solicitar aumentos significativos no limite de taxa para suportar aplicações de trading de alta frequência

### TPS Personalizado com Autenticação de Chave de API

<Note>
  Esta seção é relevante apenas se você recebeu aumentos nos limites de TPS e
  recebeu uma chave de API da equipe Helius. Usuários padrão podem pular esta
  seção.
</Note>

Se você foi aprovado para limites de TPS mais altos, receberá uma chave de API dedicada para o Sender. Para usá-la, anexe a chave de API como um parâmetro de consulta ao URL do seu endpoint:

<Tabs>
  <Tab title="Aplicações Frontend/Navegador">
    ```
    https://sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    ```
  </Tab>

  <Tab title="Aplicações Backend/Servidor">
    ```
    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>
  Precisa de mais de 50 TPS ou um plano personalizado? [Solicite limites mais
  altos](https://www.helius.dev/contact) e explore acordos de gorjeta personalizados
  para o Sender entrando em contato com nossa equipe de vendas.
</Tip>

## Suporte

Obtenha suporte através do [Painel Helius](https://dashboard.helius.dev) ou entre no [Discord](https://discord.com/invite/6GXdee3gBj) para assistência.

## Veja Também: Entrega de Shred

[Shreds Crus](UDP)]\(/pt-BR/shred-delivery/raw-shreds) é nossa entrega especializada de shreds brutos da Solana via UDP, projetada para oferecer acesso com ultra baixa latência aos dados de transação brutos da Solana.

Ao entregar shreds não processados diretamente da rede, a Entrega de Shred oferece uma vantagem competitiva para propAMMs, snipers, traders de cópia, bots de liquidação, arbitragem e operadores de nó RPC que desejam remover a latência de sincronização da rede.

<Tip>
  Comece a receber shreds brutos. [Assine a Entrega de Shred
  da Helius](https://dashboard.helius.dev/shred-delivery-seats) no seu painel.
</Tip>