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

# Solana Priority Fee API: Intelligente Transaktionsgebühren-Schätzung

> Schätzen Sie optimale Priority Fees für Solana-Transaktionen ab. Echtzeitanalyse der Gebühren mit sechs Prioritätsstufen, um schnelle Bestätigung und Kosteneffizienz zu gewährleisten.

<Info>
  **Sparen Sie Geld, verbessern Sie die Leistung**: Erhalten Sie präzise Schätzungen der Prioritätsgebühren basierend auf Echtzeit-Netzwerkbedingungen. Zahlen Sie nur das, was Sie für die gewünschte Geschwindigkeit benötigen.
</Info>

## Was sind Prioritätsgebühren?

Bei Solana ermöglichen Prioritätsgebühren, dass Ihre Transaktionen während einer Netzüberlastung die Warteschlange der Validatoren überspringen. Betrachten Sie sie als Express-Spuren für Ihre Transaktionen.

<CardGroup cols={2}>
  <Card title="Basisgebühren vs. Prioritätsgebühren" icon="coins">
    **Basisgebühren** sind feste Kosten für die Transaktionsverarbeitung

    **Prioritätsgebühren** sind optionale Zahlungen für schnellere Verarbeitung
  </Card>

  <Card title="Wie sie funktionieren" icon="rocket">
    Sie setzen einen Preis pro Berechnungseinheit fest - höhere Preise werden bei Netzüberlastung zuerst verarbeitet
  </Card>
</CardGroup>

## Warum Prioritätsgebühren verwenden

Prioritätsgebühren sind nun ein Standardbestandteil von Solana-Transaktionen und helfen, zuverlässige Bestätigungszeiten und optimale Netzwerkleistung sicherzustellen.

<CardGroup cols={2}>
  <Card title="Zuverlässige Bestätigung" icon="circle-check">
    Stellen Sie sicher, dass Ihre Transaktionen schnell und zuverlässig bestätigt werden, selbst bei wechselnden Netzwerkbedingungen
  </Card>

  <Card title="Wettbewerbsvorteil" icon="trophy">
    Bleiben Sie wettbewerbsfähig bei zeitkritischen Operationen wie Handel, Prägung und DeFi-Interaktionen
  </Card>

  <Card title="Benutzererfahrung" icon="heart">
    Bieten Sie eine konsistente und schnelle Transaktionsverarbeitung für eine bessere Benutzererfahrung
  </Card>

  <Card title="Netzwerkeffizienz" icon="gauge">
    Helfen Sie, die Ressourcenzuweisung im Netzwerk und die Gesamtleistung zu optimieren
  </Card>
</CardGroup>

## Prioritätsstufen erklärt

Unsere API bietet sechs Prioritätsstufen basierend auf der jüngsten Netzwerkaktivität:

<AccordionGroup>
  <Accordion title="Min">
    **Niedrigste beobachtete Gebühr** - Basierend auf den Mindestgebühren in den letzten Slots

    **Beste für**: Nicht dringende Transaktionen, bei denen Kostenoptimierung Priorität hat

    **Hinweis**: Kann zu langsameren Bestätigungszeiten führen
  </Accordion>

  <Accordion title="Niedrig">
    **25. Perzentil** - Kostenorientierte Option mit angemessenen Bestätigungszeiten

    **Beste für**: Standardoperationen, bei denen die Geschwindigkeit nicht kritisch ist

    **Hinweis**: Gute Balance zwischen Kosten und Zuverlässigkeit
  </Accordion>

  <Accordion title="Mittel (Empfohlen)">
    **50. Perzentil** - Mittlere Gebühr für zuverlässige Bestätigungszeiten

    **Beste für**: Die meisten Anwendungen und allgemeine Anwendungsfälle

    **Hinweis**: Empfohlener Ausgangspunkt für die meisten Entwickler
  </Accordion>

  <Accordion title="Hoch">
    **75. Perzentil** - Höhere Gebühren für schnellere Verarbeitung

    **Beste für**: Zeitkritische Operationen und wettbewerbsintensive Szenarien

    **Hinweis**: Priorisierte Verarbeitung bei Netzwerkaktivität
  </Accordion>

  <Accordion title="Sehr Hoch">
    **95. Perzentil** - Premiumgebühren für maximale Geschwindigkeit

    **Beste für**: Kritische Operationen, MEV-Strategien, dringende Transaktionen

    **Hinweis**: Schnelle Bestätigung auch bei hoher Netzwerkaktivität
  </Accordion>

  <Accordion title="Unsicher Max">
    **Maximal beobachtet** - Höchste Gebühren in den letzten Slots gesehen

    **Beste für**: Nur in Notsituationen

    **Warnung**: Oft unnötig hoch - mit Vorsicht verwenden
  </Accordion>
</AccordionGroup>

<Warning>
  **Kostenberechnung**: Gesamte Prioritätsgebühr = Preis pro Berechnungseinheit × Verwendete Berechnungseinheiten

  Eine typische Transaktion verwendet 200.000-400.000 Berechnungseinheiten. Bei der aktuellen mittleren Stufe (\~40.000 Mikrolamports pro Einheit) sind das 0,000008-0,000016 SOL an Prioritätsgebühren. Überprüfen Sie immer die aktuellen Netzwerkbedingungen für genaue Schätzungen.
</Warning>

## Implementierungsmethoden

<CardGroup cols={2}>
  <Card title="Serialisierte Transaktion (Empfohlen)" icon="file-code" href="/docs/de/priority-fee/estimating-fees-using-serialized-transaction">
    **Primäre Methode** - Analysiert Ihre genaue Transaktion für maximale Genauigkeit

    **Beste für**: Die meisten Anwendungen und Produktionsanwendungsfälle

    **Vorteile**:

    * Anweisungsspezifische Analyse
    * Höchste Genauigkeit
    * Produktionsbereit
    * Berücksichtigt die Transaktionskomplexität
  </Card>

  <Card title="Kontoschlüssel (Fortgeschritten)" icon="key" href="/docs/de/priority-fee/estimating-fees-using-account-keys">
    **Spezialisierte Anwendungsfälle** - Schätzungen basierend auf Kontomustern

    **Beste für**: Vortransaktionsanalyse, Batch-Operationen, spezialisierte Architekturen

    **Vorteile**:

    * Kontoebenen-Musteranalyse
    * Nützlich für Planung und Forschung
    * Batch-Kontoanalyse
  </Card>
</CardGroup>

## Schnellstart-Beispiel

<CodeGroup>
  ```javascript JavaScript theme={"system"}
  import { Transaction, SystemProgram, ComputeBudgetProgram } from "@solana/web3.js";
  import bs58 from "bs58";

  // 1. Build your transaction (without priority fee)
  const transaction = new Transaction();
  const transferIx = SystemProgram.transfer({
    fromPubkey: senderKeypair.publicKey,
    toPubkey: recipientPublicKey,
    lamports: 1000000, // 0.001 SOL
  });
  transaction.add(transferIx);

  // 2. Set required fields and serialize
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.feePayer = senderKeypair.publicKey;
  const serializedTx = bs58.encode(transaction.serialize());

  // 3. Get priority fee estimate
  const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        transaction: serializedTx,
        options: { 
          priorityLevel: "Medium",
          recommended: true 
        }
      }]
    })
  });

  const result = await response.json();
  const priorityFee = result.result.priorityFeeEstimate;

  // 4. Add priority fee and send
  transaction.instructions = []; // Reset
  transaction.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }));
  transaction.add(transferIx);
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.sign(senderKeypair);
  ```

  ```python Python theme={"system"}
  import requests
  import base58
  from solana.transaction import Transaction
  from solana.system_program import transfer, TransferParams

  # 1. Build and serialize your transaction
  # (transaction building code here)
  serialized_tx = base58.b58encode(transaction.serialize()).decode('utf-8')

  # 2. Get priority fee estimate
  response = requests.post(
      "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY",
      json={
          "jsonrpc": "2.0",
          "id": "1",
          "method": "getPriorityFeeEstimate",
          "params": [{
              "transaction": serialized_tx,
              "options": {
                  "priorityLevel": "Medium",
                  "recommended": True
              }
          }]
      }
  )

  result = response.json()
  priority_fee = result["result"]["priorityFeeEstimate"]
  print(f"Recommended priority fee: {priority_fee} micro-lamports")

  # 3. Rebuild transaction with priority fee and send
  ```

  ```curl cURL theme={"system"}
  curl -X POST "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "jsonrpc": "2.0",
      "id": "1",
      "method": "getPriorityFeeEstimate",
      "params": [{
        "transaction": "SERIALIZED_TRANSACTION_BASE58",
        "options": {
          "priorityLevel": "Medium",
          "recommended": true
        }
      }]
    }'
  ```
</CodeGroup>

## API-Referenz

<Card title="getPriorityFeeEstimate" icon="code" href="/docs/de/api-reference/priority-fee/getpriorityfeeestimate">
  Vollständige API-Dokumentation mit allen Parametern und Antwortformaten
</Card>

## Echtzeit-Netzwerküberwachung

<Tip>
  **Profi-Tipp**: Überwachen Sie die Netzwerkbedingungen, um Ihre Strategie für Prioritätsgebühren zu optimieren. Verwenden Sie während normaler Bedingungen niedrigere Prioritätsstufen. Bei Überlastung sollten Sie höhere Stufen für zeitkritische Operationen in Betracht ziehen.

  Sie können die aktuellen Netzwerkbedingungen mithilfe von Solana-Explorern oder der `getRecentPerformanceSamples` RPC-Methode überprüfen.
</Tip>

## Unterstützung & Ressourcen

<CardGroup cols={2}>
  <Card title="Discord-Community" icon="discord" href="https://discord.com/invite/6GXdee3gBj">
    Holen Sie sich Hilfe von der Community und dem Helius-Team
  </Card>

  <Card title="Direkter Support" icon="headset" href="/docs/de/support">
    Fragen zu Prioritätsgebühren und Optimierungshilfe
  </Card>
</CardGroup>