> ## Documentation Index
> Fetch the complete documentation index at: https://docs.phantom.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Add priority fees

> Add priority fees to transactions for faster confirmation

Add priority fees to your transactions to ensure faster confirmation during network congestion. Phantom automatically applies priority fees, but you can also set them manually.

<Tabs>
  <Tab title="React">
    ```tsx theme={null}
    import { useSolana } from "@phantom/react-sdk";
    import {
      Connection,
      PublicKey,
      VersionedTransaction,
      TransactionMessage,
      SystemProgram,
      LAMPORTS_PER_SOL,
      ComputeBudgetProgram,
    } from "@solana/web3.js";

    function SendWithPriorityFees() {
      const { solana } = useSolana();

      const sendWithPriorityFees = async (
        to: string,
        amount: number,
        priorityFee: number = 1000 // micro-lamports per compute unit
      ) => {
        const connection = new Connection("https://api.mainnet-beta.solana.com");
        const { blockhash } = await connection.getLatestBlockhash();
        const from = new PublicKey(await solana.getPublicKey());
        const recipient = new PublicKey(to);

        // Create transfer instruction
        const transferInstruction = SystemProgram.transfer({
          fromPubkey: from,
          toPubkey: recipient,
          lamports: amount * LAMPORTS_PER_SOL,
        });

        // Add priority fee instructions
        const instructions = [
          // Set compute unit limit (optional, defaults to 200,000)
          ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }),
          // Set compute unit price (priority fee)
          ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
          transferInstruction,
        ];

        const transaction = new VersionedTransaction(
          new TransactionMessage({
            payerKey: from,
            recentBlockhash: blockhash,
            instructions,
          }).compileToV0Message()
        );

        const { signature } = await solana.signAndSendTransaction(transaction);
        return signature;
      };

      return (
        <button onClick={() => sendWithPriorityFees("RECIPIENT_ADDRESS", 0.1, 5000)}>
          Send with Priority Fee
        </button>
      );
    }
    ```
  </Tab>

  <Tab title="Browser SDK">
    ```typescript theme={null}
    import { BrowserSDK, AddressType } from "@phantom/browser-sdk";
    import {
      Connection,
      PublicKey,
      VersionedTransaction,
      TransactionMessage,
      SystemProgram,
      LAMPORTS_PER_SOL,
      ComputeBudgetProgram,
    } from "@solana/web3.js";

    const sdk = new BrowserSDK({
      providers: ["google", "apple", "injected"],
      appId: "your-app-id",
      addressTypes: [AddressType.solana],
    });

    async function sendWithPriorityFees(
      to: string,
      amount: number,
      priorityFee: number = 1000
    ) {
      const connection = new Connection("https://api.mainnet-beta.solana.com");
      const { blockhash } = await connection.getLatestBlockhash();
      const from = new PublicKey(await sdk.solana.getPublicKey());
      const recipient = new PublicKey(to);

      const transferInstruction = SystemProgram.transfer({
        fromPubkey: from,
        toPubkey: recipient,
        lamports: amount * LAMPORTS_PER_SOL,
      });

      const instructions = [
        ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }),
        ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
        transferInstruction,
      ];

      const transaction = new VersionedTransaction(
        new TransactionMessage({
          payerKey: from,
          recentBlockhash: blockhash,
          instructions,
        }).compileToV0Message()
      );

      const { signature } = await sdk.solana.signAndSendTransaction(transaction);
      return signature;
    }
    ```
  </Tab>

  <Tab title="React Native">
    ```tsx theme={null}
    import { useSolana } from "@phantom/react-native-sdk";
    import {
      Connection,
      PublicKey,
      VersionedTransaction,
      TransactionMessage,
      SystemProgram,
      LAMPORTS_PER_SOL,
      ComputeBudgetProgram,
    } from "@solana/web3.js";
    import { View, Button, Alert, StyleSheet } from "react-native";

    function SendWithPriorityFees() {
      const { solana } = useSolana();

      const sendWithPriorityFees = async (
        to: string,
        amount: number,
        priorityFee: number = 1000
      ) => {
        try {
          const connection = new Connection("https://api.mainnet-beta.solana.com");
          const { blockhash } = await connection.getLatestBlockhash();
          const from = new PublicKey(await solana.getPublicKey());
          const recipient = new PublicKey(to);

          const transferInstruction = SystemProgram.transfer({
            fromPubkey: from,
            toPubkey: recipient,
            lamports: amount * LAMPORTS_PER_SOL,
          });

          const instructions = [
            ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 }),
            ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
            transferInstruction,
          ];

          const transaction = new VersionedTransaction(
            new TransactionMessage({
              payerKey: from,
              recentBlockhash: blockhash,
              instructions,
            }).compileToV0Message()
          );

          const { signature } = await solana.signAndSendTransaction(transaction);
          Alert.alert("Success", `Transaction sent: ${signature}`);
          return signature;
        } catch (error) {
          Alert.alert("Error", error instanceof Error ? error.message : "Transaction failed");
          throw error;
        }
      };

      return (
        <View style={styles.container}>
          <Button
            title="Send with Priority Fee"
            onPress={() => sendWithPriorityFees("RECIPIENT_ADDRESS", 0.1, 5000)}
          />
        </View>
      );
    }

    const styles = StyleSheet.create({
      container: {
        padding: 20,
      },
    });
    ```
  </Tab>
</Tabs>

## Priority fee recommendations

Priority fees are measured in micro-lamports per compute unit. Common values:

* **Low priority**: 1,000 - 5,000 micro-lamports (for non-urgent transactions)
* **Medium priority**: 5,000 - 25,000 micro-lamports (standard transactions)
* **High priority**: 25,000+ micro-lamports (urgent transactions during congestion)

<Info>
  **Automatic priority fees**: If you don't add priority fee instructions, Phantom will automatically calculate and apply appropriate priority fees to your transaction, provided it meets [certain requirements](/developer-powertools/solana-priority-fees#how-phantom-applies-priority-fees-to-dapp-transactions).
</Info>

## Dynamic priority fee calculation

Calculate priority fees based on recent network activity:

```typescript theme={null}
import { Connection } from "@solana/web3.js";

async function getRecommendedPriorityFee(connection: Connection): Promise<number> {
  // Get recent priority fee samples
  const feeSample = await connection.getRecentPrioritizationFees();

  if (feeSample.length === 0) {
    return 1000; // Default fallback
  }

  // Calculate median priority fee
  const fees = feeSample.map((sample) => sample.prioritizationFee);
  fees.sort((a, b) => a - b);
  const median = fees[Math.floor(fees.length / 2)];

  // Add 20% buffer for safety
  return Math.ceil(median * 1.2);
}
```