> ## 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: Pengiriman Transaksi Solana dengan Latensi Sangat Rendah

> Pengiriman transaksi Solana dengan latensi sangat rendah dan perutean multi-jalur. Tidak menggunakan kredit, menyediakan endpoint global, dan dioptimalkan untuk perdagangan berfrekuensi tinggi.

## Ikhtisar

<Note>
  **Pembaruan harga:** Sender Max kini menggunakan tip minimum sebesar **0.001 SOL**. Ini
  memasukkan Anda ke buffer tip prioritas untuk posisi teratas blok — berikan tip lebih besar agar masuk lebih dahulu. Tingkat
  [khusus SWQOS](/docs/id/sending-transactions/sender-swqos-only) yang dioptimalkan untuk biaya tetap sebesar 0.000005
  SOL.
</Note>

Helius Sender adalah layanan khusus untuk pengiriman transaksi dengan latensi sangat rendah, yang dibuat untuk perdagangan yang sensitif terhadap latensi. Layanan ini mengirimkan transaksi Anda secara bersamaan melalui semua jalur (Helius, Jito, Harmonic, Rakurai, dan sebagainya) agar transaksi dapat masuk ke blok melalui rute tercepat.

Sender **tidak menggunakan kredit API** — Anda membayar per transaksi dengan tip SOL. Layanan ini tersedia di setiap paket, termasuk tingkat gratis.

<CardGroup cols={2}>
  <Card title="No Credits" icon="coins">
    Tersedia di semua paket tanpa menggunakan kredit API. Anda membayar setiap pengiriman dengan
    tip SOL.
  </Card>

  <Card title="Multi-Path Routing" icon="arrows-split-up-and-left">
    Mengirimkan transaksi melalui semua jalur (Helius, Jito, Harmonic, Rakurai, dan sebagainya) agar dapat disertakan secepat mungkin
  </Card>

  <Card title="Global Endpoints" icon="globe">
    Endpoint HTTPS secara otomatis merutekan ke lokasi terdekat untuk frontend, sedangkan HTTP
    regional digunakan untuk backend
  </Card>

  <Card title="50 TPS (Default)" icon="gauge-high" href="https://www.helius.dev/contact">
    Perlu lebih banyak? Minta batas yang lebih tinggi dan pengaturan tip khusus
  </Card>
</CardGroup>

## Pilih tingkat Anda

Sender menawarkan dua tingkat. Keduanya memiliki latensi rendah dan tidak menggunakan kredit — perbedaannya terletak pada jumlah jalur yang dilalui transaksi Anda dan tip minimum yang diperlukan.

| Tingkat                                                    | Perutean                        | Tip minimum  | Buffer tip | Paling cocok untuk                                                        |
| ---------------------------------------------------------- | ------------------------------- | ------------ | ---------- | ------------------------------------------------------------------------- |
| [Sender Max](/docs/id/sending-transactions/sender-max)          | Semua jalur berkecepatan tinggi | 0.001 SOL    | Ya         | Transaksi yang sangat diperebutkan dan bundel yang harus masuk secepatnya |
| [Khusus SWQOS](/docs/id/sending-transactions/sender-swqos-only) | Satu jalur SWQOS                | 0.000005 SOL | Tidak      | Perdagangan hemat biaya melalui satu jalur cepat                          |

<Note>
  Tip antara 0.000005 SOL dan 0.001 SOL diterima, tetapi **tidak** dimasukkan ke
  buffer tip prioritas — tip tersebut dikirim berdasarkan upaya terbaik melalui lebih sedikit
  jalur. Untuk mendapatkan prioritas buffer dan semua jalur perutean, berikan tip setidaknya 0.001
  SOL.
</Note>

<CardGroup cols={2}>
  <Card title="Sender Max (fastest landing)" icon="trophy" href="/docs/id/sending-transactions/sender-max">
    Dirutekan melalui setiap jalur dan dimasukkan ke buffer tip prioritas untuk
    pengiriman yang paling kompetitif. Menangani transaksi dan bundel.
  </Card>

  <Card title="SWQOS-only (cost-optimized)" icon="dollar-sign" href="/docs/id/sending-transactions/sender-swqos-only">
    Tip terendah, satu jalur cepat. Tambahkan `?swqos_only=true` ke URL endpoint mana pun.
  </Card>
</CardGroup>

## Panduan Memulai Cepat

Siap mengirim transaksi Solana pertama Anda dengan latensi sangat rendah? Panduan ini membantu Anda memulai dalam hitungan menit. Bagian terbaiknya: **Anda tidak memerlukan paket berbayar atau akses khusus** — Sender tersedia bagi semua pengguna dan tidak menggunakan kredit API.

Contoh berikut menggunakan tingkat [Sender Max](/docs/id/sending-transactions/sender-max) (tip 0.001 SOL). Untuk opsi dengan tip terendah, lihat [khusus SWQOS](/docs/id/sending-transactions/sender-swqos-only).

<Steps titleSize="h3">
  <Step title="Create Your Free Helius Account">
    Mulailah dengan membuat akun gratis Anda di [Dasbor Helius](https://dashboard.helius.dev/dashboard). Sender tersedia di semua paket, termasuk tingkat gratis, dan tidak menggunakan kredit API apa pun.
  </Step>

  <Step title="Get Your API Key">
    Buka bagian [Kunci API](https://dashboard.helius.dev/api-keys) dan salin kunci Anda. Gunakan kunci ini untuk mendapatkan blockhash dan konfirmasi transaksi. Sender akan menangani pengiriman transaksi.
  </Step>

  <Step title="Send Your First Transaction">
    Mari kirim transfer SOL sederhana menggunakan Sender. Contoh ini menyertakan tip dan biaya prioritas yang diwajibkan, serta melewati preflight untuk mendapatkan latensi yang lebih rendah (opsional).

    <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">
    Anda berhasil mengirimkan transaksi melalui Sender! Berikut hal-hal yang membuatnya berfungsi:

    * Tidak ada kredit yang digunakan: Sender bebas kredit untuk semua pengguna
    * Perutean multi-jalur: Transaksi Anda dikirim secara bersamaan melalui semua jalur (Helius, Jito, Harmonic, Rakurai, dan sebagainya)
    * Tip wajib: Tip 0.001 SOL memasukkan transaksi ke buffer tip prioritas dan menggunakan setiap jalur perutean. Lihat [tingkat](#pilih-tingkat-anda) untuk opsi khusus SWQOS dengan tip lebih rendah
    * Biaya prioritas: Memberi tahu validator bahwa Anda bersedia membayar pemrosesan prioritas
    * Melewati preflight (opsional): Menukar validasi dengan kecepatan — Sender juga mendukung pemeriksaan preflight
  </Step>
</Steps>

## Persyaratan

<Warning>
  **Persyaratan wajib**: Setiap transaksi Sender harus menyertakan tip
  (minimum 0.001 SOL untuk [Sender Max](/docs/id/sending-transactions/sender-max), atau
  0.000005 SOL untuk [khusus SWQOS](/docs/id/sending-transactions/sender-swqos-only)) dan
  biaya prioritas.
</Warning>

<Note>
  `skipPreflight` bersifat opsional — Sender mendukung pemeriksaan preflight. Atur
  `skipPreflight: true` untuk menukar validasi dengan latensi yang lebih rendah.
</Note>

### Tip dan biaya prioritas

Semua transaksi yang dikirim melalui Sender **harus menyertakan tip dan biaya prioritas**:

* **Tip**: Transfer SOL ke akun tip yang ditetapkan. Minimum 0.001 SOL untuk Sender Max, atau 0.000005 SOL untuk khusus SWQOS.
* **Biaya prioritas**: Penetapan harga unit komputasi melalui `ComputeBudgetProgram.setComputeUnitPrice` untuk memprioritaskan transaksi Anda dalam antrean validator.

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

#### Mengapa keduanya diwajibkan

* **Tip**: Memberi Anda akses ke semua jalur perutean Sender (Helius, Jito, Harmonic, Rakurai, dan sebagainya) serta buffer tip prioritas
* **Biaya prioritas**: Memberi tahu validator bahwa Anda bersedia membayar pemrosesan prioritas melalui sistem prioritas bawaan Solana
* **Bersama-sama**: Tip memaksimalkan jalur yang dapat dilalui transaksi Anda, sedangkan biaya prioritas meningkatkan prioritasnya di validator — keduanya memaksimalkan kemungkinan transaksi disertakan

Gunakan [API Biaya Prioritas Helius](/docs/id/priority-fee-api) untuk mendapatkan rekomendasi biaya prioritas secara real-time.

## Endpoint

Endpoint Sender tersedia dalam beberapa konfigurasi sesuai kasus penggunaan Anda:

<Tabs>
  <Tab title="Frontend/Browser Applications">
    **Direkomendasikan untuk aplikasi frontend guna menghindari masalah CORS:**

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

    <Note>
      Endpoint HTTPS mengatasi kegagalan preflight CORS yang terjadi pada
      aplikasi berbasis browser saat menggunakan endpoint HTTP regional. Endpoint ini
      secara otomatis merutekan ke lokasi terdekat untuk mendapatkan performa
      optimal. Gunakan endpoint ini untuk kasus penggunaan frontend/browser.
    </Note>
  </Tab>

  <Tab title="Backend/Server Applications">
    **Endpoint HTTP regional untuk latensi server-ke-server yang optimal:**

    ```
    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>
      Untuk aplikasi backend/server, pilih endpoint HTTP regional yang paling dekat
      dengan infrastruktur Anda agar mendapatkan performa optimal.
    </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>

## Pemanasan Koneksi

Untuk aplikasi dengan jeda panjang antar-pengiriman transaksi, gunakan endpoint ping untuk mempertahankan koneksi yang siap digunakan dan mengurangi latensi cold start.

Endpoint ping menerima permintaan GET sederhana dan mengembalikan respons dasar untuk menjaga koneksi tetap aktif:

```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>
  Gunakan pemanasan koneksi saat aplikasi Anda memiliki jeda lebih dari 5 detik
  antartransaksi untuk mempertahankan latensi pengiriman yang optimal.
</Note>

## Format Permintaan

Sender menerima dua metode pada endpoint yang sama. Setiap pengiriman harus menyertakan tip dan biaya prioritas; melewati preflight bersifat opsional (tindakan ini menurunkan latensi).

### sendTransaction

Kirim satu transaksi. Transaksi tersebut harus memuat transfer SOL dengan tip minimum ke akun tip yang ditetapkan **dan** instruksi harga unit komputasi — tanpa keduanya, transaksi akan ditolak.

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

Lihat [Panduan Memulai Cepat](#panduan-memulai-cepat) untuk contoh `sendTransaction` lengkap yang dapat dijalankan.

### sendBundle

Kirim hingga 4 transaksi yang telah ditandatangani sepenuhnya untuk eksekusi atomik, yaitu semuanya berhasil atau semuanya gagal. Setidaknya satu transaksi harus memuat tip.

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

Lihat [bundel Sender Max](/docs/id/sending-transactions/sender-max#bundel) untuk contoh lengkap dan cara melacak masuknya transaksi.

### MEV Protect (opsional)

Untuk menghindari perutean melalui validator yang secara statistik terkait dengan serangan sandwich, tambahkan parameter kueri `mev-protect=true` ke URL endpoint. Parameter ini berfungsi pada kedua tingkat Sender serta pada `sendTransaction` dan `sendBundle`, tanpa perubahan pada isi permintaan Anda.

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

Lihat [MEV Protect](/docs/id/sending-transactions/mev-protect) untuk mengetahui cara kerjanya dan komprominya.

<Card title="API Reference" icon="code" href="/docs/id/api-reference/sender/sendtransaction">
  Lihat referensi API Sender lengkap beserta skema permintaan/respons dan
  parameternya.
</Card>

## Batas Laju dan Penskalaan

* **Batas Laju Default**: 50 transaksi per detik
* **Tanpa Penggunaan Kredit**: Transaksi Sender tidak menggunakan kredit API dari paket Anda
* **Batas Lebih Tinggi**: Pengguna paket Professional dapat meminta peningkatan batas laju yang signifikan untuk mendukung aplikasi perdagangan dengan throughput tinggi

### TPS Khusus dengan Autentikasi Kunci API

<Note>
  Bagian ini hanya relevan jika Anda telah mendapatkan peningkatan batas TPS
  dan menerima kunci API dari tim Helius. Pengguna standar dapat melewati
  bagian ini.
</Note>

Jika Anda telah disetujui untuk mendapatkan batas TPS yang lebih tinggi, Anda akan menerima kunci API khusus untuk Sender. Untuk menggunakannya, tambahkan kunci API sebagai parameter kueri ke URL endpoint Anda:

<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>
  Memerlukan lebih dari 50 TPS atau paket khusus? [Minta batas yang lebih
  tinggi](https://www.helius.dev/contact) dan jelajahi pengaturan tip khusus
  untuk Sender dengan menghubungi tim penjualan kami.
</Tip>

## Dukungan

Dapatkan dukungan melalui [Dasbor Helius](https://dashboard.helius.dev) atau bergabunglah dengan [Discord](https://discord.com/invite/6GXdee3gBj) untuk mendapatkan bantuan.

## Lihat Juga: Shred Delivery

[Shred Mentah (UDP)](/docs/id/shred-delivery/raw-shreds) adalah layanan khusus kami untuk mengirimkan shred mentah Solana melalui UDP, yang dibuat agar Anda dapat mengakses data transaksi mentah Solana dengan latensi sangat rendah.

Dengan mengirimkan shred yang belum diproses secara langsung dari jaringan, Shred Delivery memberikan keunggulan kompetitif bagi propAMM, sniper, copy trader, bot likuidasi, pelaku arbitrase, dan operator node RPC yang ingin menghilangkan latensi sinkronisasi jaringan.

<Tip>
  Mulai terima shred mentah. [Berlangganan Helius Shred
  Delivery](https://dashboard.helius.dev/shred-delivery-seats) melalui dasbor Anda.
</Tip>