> ## 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: Ultra-Low Latency Solana Transaction Submission

> Ultra-Low-Latency-Solana-Transaktionsübermittlung mit Multi-Path-Routing. Keine verbrauchten Credits, globale Endpunkte, optimiert für Hochfrequenzhandel.

## Überblick

<Note>
  **Preisanpassung:** Sender Max verwendet jetzt ein **0.001 SOL** Mindesteil. Dies
  bringt Sie in einen Priorität-Teiltopf für den Anfang des Blocks — geben Sie mehr, um zuerst anzukommen. Die kostenoptimierte
  [SWQOS-only](/docs/de/sending-transactions/sender-swqos-only) Stufe bleibt bei 0.000005
  SOL.
</Note>

Helius Sender ist ein spezialisierter Dienst für ultra-niedrige Latenz bei der Transaktionsübermittlung, entwickelt für latenzempfindlichen Handel. Er übermittelt Ihre Transaktion gleichzeitig über alle Wege (Helius, Jito, Harmonic, Rakurai, etc.), um den schnellstmöglichen Weg in einen Block zu finden.

Sender **verbraucht keine API-Credits** — Sie zahlen pro Transaktion mit einem SOL-Trinkgeld. Es ist in jedem Plan verfügbar, einschließlich der kostenlosen Stufe.

<CardGroup cols={2}>
  <Card title="Keine Credits" icon="coins">
    Verfügbar in allen Plänen ohne Verbrauch von API-Credits. Sie zahlen pro Sendung mit
    einem SOL-Trinkgeld.
  </Card>

  <Card title="Multi-Path-Routing" icon="arrows-split-up-and-left">
    Übermittelt über alle Wege (Helius, Jito, Harmonic, Rakurai, etc.) für die schnellstmögliche Aufnahme
  </Card>

  <Card title="Globale Endpunkte" icon="globe">
    HTTPS-Endpunkt leitet automatisch für Frontends zur nächsten Stelle, regionales
    HTTP für Backends
  </Card>

  <Card title="50 TPS (Standard)" icon="gauge-high" href="https://www.helius.dev/contact">
    Brauchen Sie mehr? Fordern Sie höhere Limits und kundenspezifische Trinkgeldvereinbarungen an
  </Card>
</CardGroup>

## Wählen Sie Ihre Stufe

Sender bietet zwei Stufen. Beide sind latenzarm und kreditfrei — der Unterschied besteht darin, wie viele Wege Ihre Transaktion nimmt und das erforderliche Mindesttrinkgeld.

| Stufe                                                    | Routing                       | Mindesttrinkgeld | Teiltopf | Am besten geeignet für                                                            |
| -------------------------------------------------------- | ----------------------------- | ---------------- | -------- | --------------------------------------------------------------------------------- |
| [Sender Max](/docs/de/sending-transactions/sender-max)        | Alle Hochgeschwindigkeitswege | 0.001 SOL        | Ja       | Stark umkämpfte Transaktionen und Bündel, die schnellstmögliche Landung benötigen |
| [SWQOS-only](/docs/de/sending-transactions/sender-swqos-only) | Einzelner SWQOS Weg           | 0.000005 SOL     | Nein     | Kostenoptimierter Handel auf einem schnellen Weg                                  |

<Note>
  Trinkgelder zwischen 0.000005 SOL und 0.001 SOL werden akzeptiert, haben aber **keinen** Zugang zum
  Priorität-Teiltopf — sie werden nach dem Best-Effort-Prinzip über weniger
  Wege gesendet. Um Priorität in den Topf zu erhalten und jeden Routingweg zu nutzen, geben Sie mindestens 0.001
  SOL.
</Note>

<CardGroup cols={2}>
  <Card title="Sender Max (schnellste Landung)" icon="trophy" href="/docs/de/sending-transactions/sender-max">
    Über alle Wege geleitet und in einen Priorität-Teiltopf für die
    konkurrenzfähigsten Einsendungen aufgenommen. Behandelt sowohl Transaktionen als auch Bündel.
  </Card>

  <Card title="SWQOS-only (kostenoptimiert)" icon="dollar-sign" href="/docs/de/sending-transactions/sender-swqos-only">
    Geringstes Trinkgeld, einfacher schneller Weg. Fügen Sie `?swqos_only=true` zu jeder Endpunkt-URL hinzu.
  </Card>
</CardGroup>

## Schnellstartanleitung

Bereit, Ihre erste ultra-low-latency Solana-Transaktion zu übermitteln? Diese Anleitung bringt Sie in Minuten zum Ziel. Der beste Teil: **Sie benötigen keinen kostenpflichtigen Plan oder speziellen Zugang** — Sender steht allen Benutzern zur Verfügung und verbraucht keine API-Credits.

Das folgende Beispiel verwendet die [Sender Max](/docs/de/sending-transactions/sender-max) Stufe (0.001 SOL Trinkgeld). Für die Option mit dem niedrigsten Trinkgeld siehe [SWQOS-only](/docs/de/sending-transactions/sender-swqos-only).

<Steps titleSize="h3">
  <Step title="Erstellen Sie Ihr kostenloses Helius-Konto">
    Beginnen Sie mit der Erstellung Ihres kostenlosen Kontos im [Helius-Dashboard](https://dashboard.helius.dev/dashboard). Sender steht in allen Plänen zur Verfügung, einschließlich der kostenlosen Stufe, und verbraucht keine API-Credits.
  </Step>

  <Step title="Holen Sie sich Ihren API-Schlüssel">
    Gehen Sie zum Abschnitt [API-Schlüssel](https://dashboard.helius.dev/api-keys) und kopieren Sie Ihren Schlüssel. Verwenden Sie diesen, um Blockhashes und Transaktionsbestätigungen zu erhalten. Sender kümmert sich um die Transaktionsübermittlung.
  </Step>

  <Step title="Senden Sie Ihre erste Transaktion">
    Lassen Sie uns eine einfache SOL-Übertragung mit Sender senden. Dieses Beispiel enthält das erforderliche Trinkgeld und die Prioritätsgebühr und überspringt die Preflight-Prüfung für eine niedrigere Latenz (optional).

    <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="Erfolg! Verständnis davon, was passiert ist">
    Sie haben erfolgreich eine Transaktion über Sender eingereicht! Hier ist, was es möglich gemacht hat:

    * Keine verbrauchten Credits: Sender ist für alle Benutzer kreditfrei
    * Multi-Path-Routing: Ihre Transaktion wurde gleichzeitig über alle Wege (Helius, Jito, Harmonic, Rakurai, etc.) übermittelt
    * Erforderliches Trinkgeld: Ein 0.001 SOL Trinkgeld tritt in den Priorität-Teiltopf ein und nutzt jeden Routingweg. Siehe [Stufen](#wählen-sie-ihre-stufe) für die SWQOS-only-Option mit geringeren Trinkgeldern
    * Prioritätsgebühr: Signalisiert Validatoren Ihre Bereitschaft, für priorisierte Verarbeitung zu zahlen
    * Übersprungene Preflight-Prüfung (optional): Tauscht Validierung gegen Geschwindigkeit — Sender unterstützt auch Preflight-Prüfungen
  </Step>
</Steps>

## Anforderungen

<Warning>
  **Verpflichtende Anforderungen**: Jede Sender-Transaktion muss ein Trinkgeld enthalten
  (Minimum 0.001 SOL für [Sender Max](/docs/de/sending-transactions/sender-max), oder
  0.000005 SOL für [SWQOS-only](/docs/de/sending-transactions/sender-swqos-only)) und eine
  Prioritätsgebühr.
</Warning>

<Note>
  `skipPreflight` ist optional — Sender unterstützt Preflight-Prüfungen. Setzen
  `skipPreflight: true`, um Validierung für niedrigere Latenz einzutauschen.
</Note>

### Trinkgelder und Prioritätsgebühren

Alle über Sender übermittelten Transaktionen **müssen sowohl ein Trinkgeld als auch eine Prioritätsgebühr enthalten**:

* **Trinkgeld**: Eine SOL-Überweisung auf ein vorgesehenes Trinkgeldkonto. Minimum 0.001 SOL für Sender Max oder 0.000005 SOL für SWQOS-only.
* **Prioritätsgebühr**: Berechnungseinheitspreis über `ComputeBudgetProgram.setComputeUnitPrice`, um Ihre Transaktion in der Validator-Warteschlange zu priorisieren.

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

#### Warum beides erforderlich ist

* **Trinkgelder**: Ermöglichen Ihnen den Zugriff auf alle Routingwege des Senders (Helius, Jito, Harmonic, Rakurai, etc.) und den Priorität-Teiltopf
* **Prioritätsgebühren**: Signalisieren den Validatoren Ihre Bereitschaft, für priorisierte Verarbeitung im nativen Prioritätssystem von Solana zu zahlen
* **Zusammen**: Trinkgelder maximieren die Wege, auf denen Ihre Transaktion gehen kann, während Prioritätsgebühren ihre Priorität bei den Validatoren verbessern — zusammen maximieren sie die Aufnahmechance

Verwenden Sie die [Helius Priority Fee API](/docs/de/priority-fee-api) für Echtzeit-Empfehlungen zu Prioritätsgebühren.

## Endpunkte

Sender-Endpunkte sind in mehreren Konfigurationen verfügbar, je nach Anwendungsfall:

<Tabs>
  <Tab title="Frontend-/Browser-Anwendungen">
    **Empfohlen für Frontend-Anwendungen, um CORS-Probleme zu vermeiden:**

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

    <Note>
      Der HTTPS-Endpunkt löst CORS-Preflight-Fehler, die bei
      browserbasierten Anwendungen mit den regionalen HTTP-Endpunkten auftreten. Dieser
      Endpunkt leitet automatisch zur nächsten Stelle für optimale
      Leistung. Verwenden Sie dies für Frontend-/Browser-Anwendungsfälle.
    </Note>
  </Tab>

  <Tab title="Backend-/Server-Anwendungen">
    **Regionale HTTP-Endpunkte für optimale Server-zu-Server-Latenz:**

    ```
    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>
      Für Backend-/Serveranwendungen wählen Sie den regionalen HTTP-Endpunkt, der
      Ihrer Infrastruktur am nächsten liegt, für optimale Leistung.
    </Note>
  </Tab>

  <Tab title="Verbindungsoptimierung">
    **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>

## Verbindungsoptimierung

Für Anwendungen mit langen Pausen zwischen Transaktionsübermittlungen verwenden Sie den Ping-Endpunkt, um warme Verbindungen aufrechtzuerhalten und Kaltstartlatenz zu reduzieren.

Der Ping-Endpunkt akzeptiert einfache GET-Anfragen und gibt eine grundlegende Antwort zurück, um Verbindungen aktiv zu halten:

```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>
  Nutzen Sie Verbindungsoptimierung, wenn Ihre Anwendung länger als 5 Sekunden
  zwischen Transaktionen pausiert, um die optimale Übermittlungslatenz zu erhalten.
</Note>

## Anforderungsformat

Sender akzeptiert zwei Methoden am gleichen Endpunkt. Jede Einsendung muss sowohl ein Trinkgeld als auch eine Prioritätsgebühr beinhalten; das Überspringen der Preflight-Prüfung ist optional (es reduziert die Latenz).

### sendTransaction

Senden Sie eine einzelne Transaktion. Sie muss sowohl eine SOL-Übertragung mit dem Mindest-Trinkgeld auf ein vorgesehenes Trinkgeldkonto **als auch** eine Berechnungseinheitspreis-Anweisung enthalten — ohne beides wird sie abgelehnt.

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

Sehen Sie sich die [Schnellstartanleitung](#schnellstartanleitung) für ein vollständiges, ausführbares `sendTransaction` Beispiel an.

### sendBundle

Reichen Sie bis zu 4 vollständig signierte Transaktionen für die atomare, Alles-oder-Nichts-Ausführung ein. Mindestens eine Transaktion muss das Trinkgeld enthalten.

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

Siehe [Sender Max Bündel](/docs/de/sending-transactions/sender-max#pakete) für ein vollständiges Beispiel und wie man die Landung verfolgt.

### MEV Protect (optional)

Um Validatoren zu umgehen, die statistisch mit Sandwich-Angriffen verbunden sind, fügen Sie den `mev-protect=true` Anfrageparameter zur Endpunkt-URL hinzu. Es funktioniert in beiden Sender-Stufen und auf beiden `sendTransaction` und `sendBundle`, ohne Änderungen an Ihrem Anforderungskörper.

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

Siehe [MEV Protect](/docs/de/sending-transactions/mev-protect) für wie es funktioniert und seine Kompromisse.

<Card title="API-Referenz" icon="code" href="/docs/de/api-reference/sender/sendtransaction">
  Sehen Sie sich die vollständige Sender API-Referenz mit Anforderungs-/Antwortschemata und
  Parametern an.
</Card>

## Ratenlimits und Skalierung

* **Standard-Ratenlimit**: 50 Transaktionen pro Sekunde
* **Keine Kreditnutzung**: Sender-Transaktionen verbrauchen keine API-Credits von Ihrem Plan
* **Höhere Limits**: Benutzer des Professional-Plans können signifikante Erhöhungen der Ratenlimits anfordern, um hochdurchsatzfähige Handlungsanwendungen zu unterstützen

### Benutzerdefinierte TPS mit API-Schlüsselauthentifizierung

<Note>
  Dieser Abschnitt ist nur relevant, wenn Ihnen erhöhte TPS-Limits gewährt wurden
  und Sie einen API-Schlüssel vom Helius-Team erhalten haben. Standardbenutzer können diesen
  Abschnitt überspringen.
</Note>

Wenn Sie für höhere TPS-Limits zugelassen wurden, erhalten Sie einen speziellen API-Schlüssel für Sender. Um diesen zu verwenden, hängen Sie den API-Schlüssel als Anfrageparameter an Ihre Endpunkt-URL an:

<Tabs>
  <Tab title="Frontend-/Browser-Anwendungen">
    ```
    https://sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    ```
  </Tab>

  <Tab title="Backend-/Server-Anwendungen">
    ```
    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>
  Benötigen Sie mehr als 50 TPS oder einen benutzerdefinierten Plan? [Fordern Sie höhere
  Limits an](https://www.helius.dev/contact) und erkunden Sie kundenspezifische Trinkgeldvereinbarungen
  für Sender, indem Sie unser Verkaufsteam kontaktieren.
</Tip>

## Support

Erhalten Sie Unterstützung über das [Helius Dashboard](https://dashboard.helius.dev) oder treten Sie [Discord](https://discord.com/invite/6GXdee3gBj) für Hilfe bei.

## Siehe auch: Shred Delivery

[Raw Shreds (UDP)](/docs/de/shred-delivery/raw-shreds) ist unsere spezialisierte Lieferung roher Solana-Shreds über UDP, entwickelt, um Ihnen ultra-low-latency Zugang zu Solanas rohen Transaktionsdaten zu geben.

Durch die direkte Lieferung unbearbeiteter Shreds vom Netzwerk bietet Shred Delivery einen Wettbewerbsvorteil für propAMMs, Sniper, Kopiehändler, Liquidations-Bots, Arbitrage und RPC-Node-Betreiber, die Netzwerksynchronisationslatenz entfernen möchten.

<Tip>
  Beginnen Sie mit dem Empfang roher Shreds. [Abonnieren Sie Helius Shred
  Delivery](https://dashboard.helius.dev/shred-delivery-seats) in Ihrem Dashboard.
</Tip>