> ## 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: 초저지연 Solana 거래 제출

> 다중 경로 라우팅을 통한 초저지연 Solana 거래 제출. 크레딧 소모 없음, 글로벌 엔드포인트, 고빈도 거래에 최적화.

## 개요

<Note>
  **가격 업데이트:** Sender Max는 이제 최소 **0.001 SOL** 팁을 사용합니다. 블록 상단에 올라가기 위한 우선 팁 버퍼에 들어가려면 더 팁을 주세요. 비용 최적화된 [SWQOS-only](/docs/ko/sending-transactions/sender-swqos-only) 계층은 0.000005 SOL에서 유지됩니다.
</Note>

Helius Sender는 지연 민감 거래를 위해 설계된 초저지연 거래 제출을 위한 전문 서비스입니다. Helius, Jito, Harmonic, Rakurai 등 모든 경로로 동시에 거래를 제출하여 가능한 가장 빠른 경로로 블록에 들어가게 합니다.

Sender는 **API 크레딧을 소모하지 않습니다** — SOL 팁으로 거래당 지불합니다. 무료 계층을 포함하여 모든 플랜에서 사용 가능합니다.

<CardGroup cols={2}>
  <Card title="크레딧 없음" icon="coins">
    모든 플랜에서 API 크레딧을 소모하지 않고 이용할 수 있습니다. 송신당 SOL 팁으로 지불합니다.
  </Card>

  <Card title="다중 경로 라우팅" icon="arrows-split-up-and-left">
    가능한 가장 빠른 포함을 위해 모든 경로 (Helius, Jito, Harmonic, Rakurai 등)로 제출
  </Card>

  <Card title="글로벌 엔드포인트" icon="globe">
    HTTPS 엔드포인트는 프론트엔드에 가장 가까운 위치로 자동 라우트되고, 지역 HTTP는 백엔드에 사용됩니다
  </Card>

  <Card title="50 TPS (기본값)" icon="gauge-high" href="https://www.helius.dev/contact">
    더 많은 수요가 필요하신가요? 높은 한도와 맞춤 팁 배열 요청
  </Card>
</CardGroup>

## 계층 선택

Sender는 두 가지 계층을 제공합니다. 둘 다 저지연과 크레딧 무료입니다 — 차이점은 거래가 사용하는 경로 수와 필요한 최소 팁입니다.

| Tier                                                     | Routing     | Minimum tip  | Tip buffer | Best for                       |
| -------------------------------------------------------- | ----------- | ------------ | ---------- | ------------------------------ |
| [Sender Max](/docs/ko/sending-transactions/sender-max)        | 모든 고속 경로    | 0.001 SOL    | Yes        | 가장 빠르게 착지해야 하는 경쟁이 치열한 거래 및 번들 |
| [SWQOS-only](/docs/ko/sending-transactions/sender-swqos-only) | 단일 SWQOS 경로 | 0.000005 SOL | No         | 하나의 빠른 경로에서 비용 최적화된 거래         |

<Note>
  0.000005 SOL에서 0.001 SOL 사이의 팁은 수용되지만 우선 팁 버퍼에 들어가지 **않습니다** — 가능한 경우 적은 경로로 최대한 노력하여 전송됩니다. 버퍼 우선순위와 모든 라우팅 경로를 얻으려면 최소 0.001 SOL 이상 팁을 주십시오.
</Note>

<CardGroup cols={2}>
  <Card title="Sender Max (가장 빠른 착지)" icon="trophy" href="/docs/ko/sending-transactions/sender-max">
    모든 경로로 라우팅되고 가장 경쟁력 있는 제출을 위해 우선 팁 버퍼에 들어갑니다. 거래 및 번들을 모두 처리합니다.
  </Card>

  <Card title="SWQOS-only (비용 최적화)" icon="dollar-sign" href="/docs/ko/sending-transactions/sender-swqos-only">
    가장 낮은 팁, 단일 빠른 경로. `?swqos_only=true`를 모든 엔드포인트 URL에 추가하십시오.
  </Card>
</CardGroup>

## 빠른 시작 가이드

첫 번째 초저지연 Solana 거래를 제출할 준비가 되셨나요? 이 가이드는 몇 분 내로 시작할 수 있게 도와드립니다. 최고의 장점: **유료 플랜이나 특별한 접근이 필요 없습니다** — Sender는 모든 사용자에게 제공되며 API 크레딧을 소모하지 않습니다.

아래 예제는 [Sender Max](/docs/ko/sending-transactions/sender-max) 계층(0.001 SOL 팁)을 사용합니다. 가장 낮은 팁 옵션은 [SWQOS-only](/docs/ko/sending-transactions/sender-swqos-only)를 참조하십시오.

<Steps titleSize="h3">
  <Step title="무료 Helius 계정 생성">
    [Helius 대시보드](https://dashboard.helius.dev/dashboard)에서 무료 계정을 생성하세요. Sender는 모든 플랜, 무료 계층 포함, 에서 제공되며 API 크레딧을 소모하지 않습니다.
  </Step>

  <Step title="API 키 가져오기">
    [API 키](https://dashboard.helius.dev/api-keys) 섹션으로 이동하여 키를 복사하세요. 블록 해시 가져오기 및 거래 확인에 사용하세요. Sender는 거래 제출을 처리합니다.
  </Step>

  <Step title="첫 거래 송신">
    Sender를 사용하여 간단한 SOL 전송을 해봅시다. 이 예에는 필수 팁과 우선 수수료가 포함되어 있으며, 낮은 지연을 위해 사전 비행을 건너뜁니다 (선택 사항).

    <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="성공! 무슨 일이 일어났는지 이해하기">
    Sender를 통해 거래를 성공적으로 제출했습니다! 성공 요인은 다음과 같습니다:

    * 크레딧 소모 없음: Sender는 모든 사용자에게 크레딧 걱정 없이 제공됩니다
    * 다중 경로 라우팅: 거래가 Helius, Jito, Harmonic, Rakurai 등 모든 경로로 동시에 제출되었습니다
    * 필수 팁: 0.001 SOL 팁은 우선 팁 버퍼에 들어가고 모든 라우팅 경로를 사용합니다. 낮은 팁 옵션인 SWQOS-only 계층을 참조하십시오
    * 우선 수수료: 검증자에게 우선 순위 처리를 위한 비용 지급 의사를 나타냅니다
    * 사전 비행 건너뜀 (선택 사항): 속도를 위해 유효성 검사를 생략 — Sender는 사전 비행 검사를 지원합니다
  </Step>
</Steps>

## 요구사항

<Warning>
  **필수 요구사항**: 모든 Sender 거래는 [Sender Max](/docs/ko/sending-transactions/sender-max)의 최소 0.001 SOL 팁 또는 [SWQOS-only](/docs/ko/sending-transactions/sender-swqos-only)의 0.000005 SOL 팁과 우선 수수료를 포함해야 합니다.
</Warning>

<Note>
  `skipPreflight`는 선택 사항입니다 — Sender는 사전 비행 검사 지원을 제공합니다. 낮은 지연을 위해 유효성 검사 무시 설정은 `skipPreflight: true`를 사용하세요.
</Note>

### 팁과 우선 수수료

Sender를 통해 제출된 모든 거래에는 **팁과 우선 수수료가 포함되어야 합니다**:

* **팁**: 지정된 팁 계정으로의 SOL 전송. Sender Max의 최소 0.001 SOL, SWQOS-only의 최소 0.000005 SOL.
* **우선 수수료**: 검증자 큐에서 거래를 우선 처리하기 위한 UNIT\_PRICE\_PLACEHOLDER를 통한 컴퓨팅 유닛 가격 설정.

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

#### 둘 다 필요한 이유

* **팁**: Sender의 모든 라우팅 경로(Helius, Jito, Harmonic, Rakurai 등)와 우선 팁 버퍼 사용 제공
* **우선 수수료**: Solana의 기본 우선 처리 시스템을 통해 검증자에게 우선 순위 처리를 위한 비용 지급 의사 신호
* **둘의 조합**: 팁은 거래가 갈 수 있는 경로를 최대화하고, 우선 수수료는 검증자와의 우선 순위를 높여 함께 포함 확률을 최대화합니다

실시간 우선 수수료 권장 사항은 [Helius Priority Fee API](/docs/ko/priority-fee-api)를 사용하세요.

## 엔드포인트

Sender 엔드포인트는 사용 사례에 따라 여러 구성을 제공합니다:

<Tabs>
  <Tab title="프론트엔드/브라우저 애플리케이션">
    **CORS 문제를 피하기 위해 프론트엔드 애플리케이션에 권장:**

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

    <Note>
      HTTPS 엔드포인트는 브라우저 기반 애플리케이션에서 지역 HTTP 엔드포인트를 사용할 때 발생하는 CORS 사전 비행 오류를 해결합니다. 이 엔드포인트는 최적의 성능을 위해 가장 가까운 위치로 자동 라우팅됩니다. 프론트엔드/브라우저 사용 사례에 사용하세요.
    </Note>
  </Tab>

  <Tab title="백엔드/서버 애플리케이션">
    **최적의 서버 간 지연을 위한 지역 HTTP 엔드포인트:**

    ```
    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>
      백엔드/서버 애플리케이션의 경우, 최적의 성능을 위해 인프라에 가장 가까운 지역 HTTP 엔드포인트를 선택하세요.
    </Note>
  </Tab>

  <Tab title="연결 예열">
    **HTTPS (프론트엔드):**

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

    **HTTP (백엔드):**

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

## 연결 예열

거래 제출 사이에 긴 간격이 있는 애플리케이션은 핑 엔드포인트를 사용하여 연결을 유지하고 콜드 스타트 지연을 줄이십시오.

핑 엔드포인트는 간단한 GET 요청을 수락하고 연결을 유지하기 위한 기본 응답을 반환합니다:

```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>
  거래 사이에 5초 이상의 간격이 있을 때 최적의 제출 지연을 유지하기 위해 연결 예열을 사용하세요.
</Note>

## 요청 형식

Sender는 동일한 엔드포인트에서 두 가지 방법을 수락합니다. 모든 제출은 팁과 우선 수수료를 포함해야 하며, 사전 비행 건너뛰기는 선택 사항입니다 (지연 시간 단축).

### sendTransaction

단일 거래 제출. 지정된 팁 계정으로 최소 팁을 포함한 SOL 전송 **및** 컴퓨팅 유닛 가격 지시어를 모두 포함해야 합니다 — 둘 다 없으면 거부됩니다.

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

완전하고 실행 가능한 `sendTransaction` 예를 보려면 [빠른 시작](#빠른-시작-가이드)을 참조하십시오.

### sendBundle

최대 4개의 완전 서명된 거래를 원자적으로 제출하여 모든 것이 실행되거나 아무것도 실행되지 않도록 합니다. 적어도 하나의 거래는 팁을 포함해야 합니다.

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

전체 예제 및 착지 추적 방법은 [Sender Max 번들](/docs/ko/sending-transactions/sender-max#번들)을 참조하세요.

### MEV Protect (선택 사항)

샌드위치 공격과 통계적으로 연결된 검증자를 우회하기 위해 `mev-protect=true` 쿼리 매개 변수를 엔드포인트 URL에 추가하세요. 이는 Sender의 두 계층에서 모두 작동하며, 요청 본문 변경 없이 `sendTransaction` 및 `sendBundle` 모두에서 작동합니다.

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

작동 방식 및 트레이드오프는 [MEV Protect](/docs/ko/sending-transactions/mev-protect)를 참조하세요.

<Card title="API 참조" icon="code" href="/docs/ko/api-reference/sender/sendtransaction">
  요청/응답 스키마 및 매개 변수가 포함된 완전한 Sender API 참조 보기.
</Card>

## 속도 제한 및 확장

* **기본 속도 제한**: 초당 50 거래
* **크레딧 사용 없음**: Sender 거래는 플랜의 API 크레딧을 소모하지 않습니다
* **더 높은 한도**: 고스루풋 거래 응용 프로그램을 지원하기 위해 전문 플랜 사용자는 상당한 속도 제한 증가를 요청할 수 있습니다

### API 키 인증을 통한 맞춤 TPS

<Note>
  이 섹션은 TPS 한도가 증가하고 Helius 팀으로부터 API 키를 받은 경우에만 관련이 있습니다. 일반 사용자는 이 섹션을 건너뛰어도 됩니다.
</Note>

더 높은 TPS 한도가 승인된 경우, Sender를 위한 전용 API 키를 받게 됩니다. 이를 사용하려면 API 키를 쿼리 매개 변수로 엔드포인트 URL에 추가하십시오:

<Tabs>
  <Tab title="프론트엔드/브라우저 애플리케이션">
    ```
    https://sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    ```
  </Tab>

  <Tab title="백엔드/서버 애플리케이션">
    ```
    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>
  50 TPS 이상의 맞춤형 플랜이 필요하신가요? [더 높은 한도 요청](https://www.helius.dev/contact) 및 Sender에 대한 맞춤 팁 배열 탐색을 영업팀에 문의하세요.
</Tip>

## 지원

[Helius 대시보드](https://dashboard.helius.dev)를 통해 지원을 받거나 [Discord](https://discord.com/invite/6GXdee3gBj)에 가입하여 도움을 받으세요.

## 또한 참고: Shred Delivery

[Raw Shreds (UDP)](/docs/ko/shred-delivery/raw-shreds)는 초저지연 Solana의 원시 거래 데이터에 액세스하기 위해 설계된 UDP를 통한 특수 전달입니다.

네트워크에서 직접 처리되지 않은 시레드를 제공하여 propAMMs, 스나이퍼, 카피 트레이더, 청산 봇, 차익 거래 및 RPC 노드 운영자가 네트워크 동기화 지연을 제거할 수 있는 경쟁 우위를 제공합니다.

<Tip>
  원시 시레드를 받기 시작하세요. 대시보드에서 [Helius Shred Delivery](https://dashboard.helius.dev/shred-delivery-seats)를 구독하세요.
</Tip>