> ## 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 : Estimation des frais de transaction intelligents

> Estimez les frais prioritaires optimaux pour les transactions Solana. Analyse des frais en temps réel avec six niveaux de priorité pour garantir une confirmation rapide et une efficacité des coûts.

<Info>
  **Économisez de l'argent, améliorez les performances** : Obtenez des estimations précises des frais prioritaires basées sur les conditions réelles du réseau. Ne payez que ce dont vous avez besoin pour la vitesse souhaitée.
</Info>

## Qu'est-ce que les frais prioritaires ?

Sur Solana, les frais prioritaires permettent à vos transactions d'avancer dans la file d'attente du validateur en cas de congestion du réseau. Pensez-y comme des voies express pour vos transactions.

<CardGroup cols={2}>
  <Card title="Frais de base vs Frais prioritaires" icon="coins">
    **Les frais de base** sont des coûts fixes pour le traitement des transactions

    **Les frais prioritaires** sont des paiements optionnels pour un traitement plus rapide
  </Card>

  <Card title="Comment ça fonctionne" icon="rocket">
    Vous définissez un prix par unité de calcul - les prix plus élevés sont traités en premier en cas de congestion du réseau
  </Card>
</CardGroup>

## Pourquoi utiliser les frais prioritaires

Les frais prioritaires font maintenant partie intégrante des transactions Solana, aidant à garantir des temps de confirmation fiables et des performances optimales du réseau.

<CardGroup cols={2}>
  <Card title="Confirmation Fiable" icon="circle-check">
    Assurez-vous que vos transactions se confirment rapidement et de manière fiable, même pendant des conditions de réseau variables
  </Card>

  <Card title="Avantage Concurrentiel" icon="trophy">
    Restez compétitif dans les opérations sensibles au temps comme le trading, le minting et les interactions DeFi
  </Card>

  <Card title="Expérience Utilisateur" icon="heart">
    Fournissez un traitement cohérent et rapide des transactions pour une meilleure expérience utilisateur
  </Card>

  <Card title="Efficacité du Réseau" icon="gauge">
    Aidez à optimiser l'allocation des ressources du réseau et les performances générales
  </Card>
</CardGroup>

## Explication des niveaux de priorité

Notre API propose six niveaux de priorité basés sur l'activité récente du réseau :

<AccordionGroup>
  <Accordion title="Min">
    **Frais observés les plus bas** - Basé sur les frais minimums observés dans les créneaux récents

    **Idéal pour** : Transactions non urgentes où l'optimisation des coûts est une priorité

    **Note** : Peut entraîner des temps de confirmation plus lents
  </Accordion>

  <Accordion title="Bas">
    **25e centile** - Option économique avec des temps de confirmation raisonnables

    **Idéal pour** : Opérations standard où la vitesse n'est pas critique

    **Note** : Bon équilibre entre coût et fiabilité
  </Accordion>

  <Accordion title="Moyen (Recommandé)">
    **50e centile** - Frais médians fournissant des temps de confirmation fiables

    **Idéal pour** : La plupart des applications et des cas d'utilisation généraux

    **Note** : Point de départ recommandé pour la plupart des développeurs
  </Accordion>

  <Accordion title="Élevé">
    **75e centile** - Frais plus élevés pour un traitement plus rapide

    **Idéal pour** : Opérations sensibles au temps et scénarios concurrentiels

    **Note** : Traitement prioritaire en cas d'activité réseau
  </Accordion>

  <Accordion title="Très Élevé">
    **95e centile** - Frais premium pour une vitesse maximale

    **Idéal pour** : Opérations critiques, stratégies MEV, transactions urgentes

    **Note** : Confirmation rapide même lors d'une activité réseau intense
  </Accordion>

  <Accordion title="UnsafeMax">
    **Maximum observé** - Frais les plus hauts observés dans les créneaux récents

    **Idéal pour** : Situations d'urgence uniquement

    **Avertissement** : Souvent inutilement élevé - à utiliser avec précaution
  </Accordion>
</AccordionGroup>

<Warning>
  **Calcul des coûts** : Frais prioritaires totaux = Prix par unité de calcul × Unités de calcul consommées

  Une transaction typique utilise 200 000 à 400 000 unités de calcul. Au niveau Moyen actuel (\~40 000 microlamports par unité), cela représente 0,000008 à 0,000016 SOL en frais prioritaires. Vérifiez toujours les conditions actuelles du réseau pour des estimations précises.
</Warning>

## Méthodes de mise en œuvre

<CardGroup cols={2}>
  <Card title="Transaction Sérialisée (Recommandé)" icon="file-code" href="/docs/fr/priority-fee/estimating-fees-using-serialized-transaction">
    **Méthode Principale** - Analyse votre transaction exacte pour une précision maximale

    **Idéal pour** : La plupart des applications et des cas d'utilisation en production

    **Avantages** :

    * Analyse spécifique à l'instruction
    * Précision maximale
    * Prêt pour la production
    * Prend en compte la complexité des transactions
  </Card>

  <Card title="Clés de Compte (Avancé)" icon="key" href="/docs/fr/priority-fee/estimating-fees-using-account-keys">
    **Cas d'utilisation spécialisés** - Estimations basées sur les modèles de compte

    **Idéal pour** : Analyse préalable à la transaction, opérations en lots, architectures spécialisées

    **Avantages** :

    * Analyse des modèles au niveau du compte
    * Utile pour la planification et la recherche
    * Analyse des comptes en lots
  </Card>
</CardGroup>

## Exemple de démarrage rapide

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

## Référence API

<Card title="getPriorityFeeEstimate" icon="code" href="/docs/fr/api-reference/priority-fee/getpriorityfeeestimate">
  Documentation complète de l'API avec tous les paramètres et formats de réponse
</Card>

## Surveillance du réseau en temps réel

<Tip>
  **Astuce pro** : Surveillez les conditions du réseau pour optimiser votre stratégie de frais prioritaires. En périodes normales, utilisez des niveaux de priorité inférieurs. En cas de congestion, envisagez des niveaux plus élevés pour les opérations sensibles au temps.

  Vous pouvez vérifier les conditions actuelles du réseau en utilisant les explorateurs Solana ou la méthode `getRecentPerformanceSamples` RPC.
</Tip>

## Support & Ressources

<CardGroup cols={2}>
  <Card title="Communauté Discord" icon="discord" href="https://discord.com/invite/6GXdee3gBj">
    Obtenez de l'aide de la communauté et de l'équipe Helius
  </Card>

  <Card title="Support Direct" icon="headset" href="/docs/fr/support">
    Questions sur les frais prioritaires et assistance à l'optimisation
  </Card>
</CardGroup>