> ## 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 Estimation: Serialized Transaction Method

> Get the most accurate Solana priority fee estimates using serialized transactions with the Helius Priority Fee API. Perfect for production applications.

> [!NOTE]
>
> **Most Accurate Method**: Get the highest precision priority fee estimates by analyzing your exact transaction. Recommended for production applications where accuracy matters most.

## Overview

Serialized transactions provide the most accurate fee estimates because the API can analyze the exact accounts and operations that will be performed in your transaction.

> [card] Why Use Serialized Transactions
>
> * **Highest accuracy** - Analyzes exact operations
> * **Detailed analysis** - Instruction-specific patterns
> * **Realistic estimates** - Reflects actual transaction
> * **Production-ready** - Built for critical applications

> [card] Best For
>
> * Production applications
> * Complex transactions
> * Critical operations
> * Maximum accuracy needed

## Advantages Over Account Keys

> [tab] Accuracy Benefits
>
> > [card] Instruction-Specific Analysis
> >
> > The API can analyze specific operations and their historical fee patterns, not just account activity.
>
> > [card] Transaction Size Awareness
> >
> > Considers the actual size and complexity of your transaction for more accurate estimates.
>
> > [card] Read-Only Account Handling
> >
> > Better analysis of both writable and read-only accounts in their transaction context.

> [tab] Real-World Benefits
>
> ### DeFi Trading
>
> More accurate estimates for complex swap operations
>
> ### NFT Minting
>
> Better estimates for mint transactions with specific metadata
>
> ### Multi-instruction Transactions
>
> Accurate fees for complex multi-step operations
>
> ### Program Interactions
>
> Better estimates for specific program calls

## Implementation Guide

**1. Build Your Transaction**

Create your transaction with all instructions (except priority fee)

**2. Serialize the Transaction**

Convert your transaction to a serialized format

**3. Get Fee Estimate**

Call the Priority Fee API with your serialized transaction

**4. Apply Priority Fee**

Add the priority fee instruction and send your transaction

### Quick Start Example

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

const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY");

// 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 priorityFee = await getPriorityFeeEstimate(connection, serializedTx, "Medium");

// 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 json
from solana.transaction import Transaction
from solana.system_program import transfer, TransferParams

# Build and serialize transaction
def get_serialized_transaction():
    # Build your transaction here
    # Return base58 encoded serialized transaction
    pass

# Get priority fee estimate
def get_priority_fee_estimate(serialized_tx, priority_level="Medium"):
    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": priority_level,
                    "recommended": True
                }
            }]
        }
    )
    return response.json()["result"]["priorityFeeEstimate"]

# Usage
serialized_tx = get_serialized_transaction()
fee = get_priority_fee_estimate(serialized_tx, "High")
print(f"Priority fee: {fee} micro-lamports")
```

## Core Implementation Function

Here's a reusable function for getting priority fee estimates from serialized transactions:

```javascript theme={"system"}
async function getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel = "Medium") {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        transaction: serializedTransaction,
        options: { 
          priorityLevel: priorityLevel,
          recommended: true 
        }
      }]
    })
  });
  
  const result = await response.json();
  
  if (result.error) {
    throw new Error(`Fee estimation failed: ${JSON.stringify(result.error)}`);
  }
  
  return result.result.priorityFeeEstimate;
}
```

## Complete Implementation Examples

> [tab] Simple Transfer
>
> > [accordion] Expand to see complete example
> >
> > ```javascript theme={"system"}
> > const { 
> >   Connection, 
> >   PublicKey, 
> >   Transaction, 
> >   SystemProgram, 
> >   ComputeBudgetProgram, 
> >   sendAndConfirmTransaction,
> >   Keypair
> > } = require("@solana/web3.js");
> > const bs58 = require("bs58");
> >
> > // Initialize connection and accounts
> > const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY");
> > const senderKeypair = Keypair.fromSecretKey(bs58.decode("YOUR_PRIVATE_KEY"));
> > const receiverPublicKey = new PublicKey("RECIPIENT_PUBLIC_KEY");
> >
> > async function sendTransactionWithPriorityFee(amount, priorityLevel = "Medium") {
> >   // 1. Create transaction with transfer instruction
> >   const transaction = new Transaction();
> >   const transferIx = SystemProgram.transfer({
> >     fromPubkey: senderKeypair.publicKey,
> >     toPubkey: receiverPublicKey,
> >     lamports: amount,
> >   });
> >   transaction.add(transferIx);
> >
> >   // 2. Set required fields for serialization
> >   transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
> >   transaction.feePayer = senderKeypair.publicKey;
> >
> >   // 3. Serialize the transaction
> >   const serializedTransaction = bs58.encode(transaction.serialize());
> >
> >   // 4. Get priority fee estimate
> >   const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
> >   console.log(`Estimated ${priorityLevel} priority fee: ${priorityFee} micro-lamports`);
> >
> >   // 5. Reset transaction and add priority fee instruction first
> >   transaction.instructions = [];
> >
> >   // Add priority fee instruction
> >   const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
> >     microLamports: priorityFee
> >   });
> >   transaction.add(priorityFeeIx);
> >
> >   // Re-add the original transfer instruction
> >   transaction.add(transferIx);
> >
> >   // 6. Update blockhash and sign
> >   transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
> >   transaction.sign(senderKeypair);
> >
> >   // 7. Send the transaction
> >   try {
> >     const signature = await sendAndConfirmTransaction(
> >       connection,
> >       transaction,
> >       [senderKeypair],
> >       { maxRetries: 0 } // Set to 0 for staked connection usage
> >     );
> >     console.log(`Transaction successful with signature: ${signature}`);
> >     return signature;
> >   } catch (error) {
> >     console.error("Error sending transaction:", error);
> >     throw error;
> >   }
> > }
> >
> > // Usage
> > sendTransactionWithPriorityFee(1000000, "High"); // Send 0.001 SOL with high priority
> > ```

> [tab] Token Transfer
>
> > [accordion] Expand to see complete example
> >
> > ```javascript theme={"system"}
> > const { 
> >   Connection, 
> >   PublicKey, 
> >   Transaction, 
> >   ComputeBudgetProgram,
> >   sendAndConfirmTransaction,
> >   Keypair
> > } = require("@solana/web3.js");
> > const { 
> >   createTransferInstruction,
> >   getAssociatedTokenAddress,
> >   TOKEN_PROGRAM_ID,
> >   ASSOCIATED_TOKEN_PROGRAM_ID
> > } = require("@solana/spl-token");
> > const bs58 = require("bs58");
> >
> > async function sendTokenWithPriorityFee(
> >   connection,
> >   senderKeypair,
> >   recipientPublicKey,
> >   mintAddress,
> >   amount,
> >   priorityLevel = "Medium"
> > ) {
> >   // 1. Get token account addresses
> >   const senderTokenAccount = await getAssociatedTokenAddress(
> >     mintAddress,
> >     senderKeypair.publicKey
> >   );
> >
> >   const recipientTokenAccount = await getAssociatedTokenAddress(
> >     mintAddress,
> >     recipientPublicKey
> >   );
> >
> >   // 2. Create transaction with token transfer instruction
> >   const transaction = new Transaction();
> >   const transferIx = createTransferInstruction(
> >     senderTokenAccount,
> >     recipientTokenAccount,
> >     senderKeypair.publicKey,
> >     amount,
> >     [],
> >     TOKEN_PROGRAM_ID
> >   );
> >   transaction.add(transferIx);
> >
> >   // 3. Set required fields and serialize
> >   transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
> >   transaction.feePayer = senderKeypair.publicKey;
> >   const serializedTransaction = bs58.encode(transaction.serialize());
> >
> >   // 4. Get priority fee estimate
> >   const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
> >   console.log(`Token transfer priority fee: ${priorityFee} micro-lamports`);
> >
> >   // 5. Reset and rebuild transaction with priority fee
> >   transaction.instructions = [];
> >
> >   // Add priority fee instruction first
> >   const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
> >     microLamports: priorityFee
> >   });
> >   transaction.add(priorityFeeIx);
> >
> >   // Re-add the transfer instruction
> >   transaction.add(transferIx);
> >
> >   // 6. Update blockhash and send
> >   transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
> >   transaction.sign(senderKeypair);
> >
> >   const signature = await sendAndConfirmTransaction(
> >     connection,
> >     transaction,
> >     [senderKeypair],
> >     { maxRetries: 0 }
> >   );
> >
> >   return signature;
> > }
> > ```

> [tab] Complex Multi-Instruction
>
> > [accordion] Expand to see complete example
> >
> > ```javascript theme={"system"}
> > async function complexTransactionWithPriorityFee(connection, keypair) {
> >   // 1. Build complex transaction with multiple instructions
> >   const transaction = new Transaction();
> >
> >   // Add multiple instructions
> >   const createAccountIx = SystemProgram.createAccount({
> >     fromPubkey: keypair.publicKey,
> >     newAccountPubkey: newAccountKeypair.publicKey,
> >     lamports: await connection.getMinimumBalanceForRentExemption(165),
> >     space: 165,
> >     programId: TOKEN_PROGRAM_ID,
> >   });
> >
> >   const initializeAccountIx = createInitializeAccountInstruction(
> >     newAccountKeypair.publicKey,
> >     mintAddress,
> >     keypair.publicKey,
> >     TOKEN_PROGRAM_ID
> >   );
> >
> >   const transferIx = SystemProgram.transfer({
> >     fromPubkey: keypair.publicKey,
> >     toPubkey: recipientPublicKey,
> >     lamports: 1000000,
> >   });
> >
> >   transaction.add(createAccountIx);
> >   transaction.add(initializeAccountIx);
> >   transaction.add(transferIx);
> >
> >   // 2. Set required fields and serialize
> >   transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
> >   transaction.feePayer = keypair.publicKey;
> >   const serializedTransaction = bs58.encode(transaction.serialize());
> >
> >   // 3. Get priority fee estimate for complex transaction
> >   const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, "High");
> >   console.log(`Complex transaction priority fee: ${priorityFee} micro-lamports`);
> >
> >   // 4. Rebuild transaction with priority fee
> >   transaction.instructions = [];
> >
> >   // Add priority fee instruction first
> >   const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
> >     microLamports: priorityFee
> >   });
> >   transaction.add(priorityFeeIx);
> >
> >   // Optional: Set compute unit limit for complex transactions
> >   const computeLimitIx = ComputeBudgetProgram.setComputeUnitLimit({
> >     units: 400000 // Adjust based on your transaction complexity
> >   });
> >   transaction.add(computeLimitIx);
> >
> >   // Re-add all original instructions
> >   transaction.add(createAccountIx);
> >   transaction.add(initializeAccountIx);
> >   transaction.add(transferIx);
> >
> >   // 5. Update blockhash and send
> >   transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
> >   transaction.sign(keypair, newAccountKeypair);
> >
> >   const signature = await sendAndConfirmTransaction(
> >     connection,
> >     transaction,
> >     [keypair, newAccountKeypair],
> >     { maxRetries: 0 }
> >   );
> >
> >   return signature;
> > }
> > ```

## Advanced Configuration Options

> [accordion] Include All Priority Levels
>
> Get estimates for all priority levels at once:
>
> ```javascript theme={"system"}
> async function getAllPriorityLevels(connection, serializedTransaction) {
>   const response = await fetch(connection.rpcEndpoint, {
>     method: "POST",
>     headers: { "Content-Type": "application/json" },
>     body: JSON.stringify({
>       jsonrpc: "2.0",
>       id: "1",
>       method: "getPriorityFeeEstimate",
>       params: [{
>         transaction: serializedTransaction,
>         options: { 
>           includeAllPriorityFeeLevels: true
>         }
>       }]
>     })
>   });
>
>   const result = await response.json();
>   return result.result.priorityFeeLevels;
> }
>
> // Usage
> const allLevels = await getAllPriorityLevels(connection, serializedTransaction);
> console.log("All priority levels:", allLevels);
> /*
> Output:
> {
>   "min": 0,
>   "low": 1000, 
>   "medium": 5000,
>   "high": 15000,
>   "veryHigh": 50000,
>   "unsafeMax": 100000
> }
> */
> ```

> [accordion] Include Detailed Analysis
>
> Request detailed information about the fee calculation:
>
> ```javascript theme={"system"}
> async function getDetailedFeeAnalysis(connection, serializedTransaction) {
>   const response = await fetch(connection.rpcEndpoint, {
>     method: "POST",
>     headers: { "Content-Type": "application/json" },
>     body: JSON.stringify({
>       jsonrpc: "2.0",
>       id: "1",
>       method: "getPriorityFeeEstimate",
>       params: [{
>         transaction: serializedTransaction,
>         options: { 
>           includeDetails: true,
>           priorityLevel: "Medium"
>         }
>       }]
>     })
>   });
>
>   const result = await response.json();
>   console.log("Detailed analysis:", result.result);
>   return result.result;
> }
> ```
>
> This provides insights into how the fee was calculated, including per-account analysis.

> [accordion] Custom Lookback Period
>
> Adjust the number of slots analyzed:
>
> ```javascript theme={"system"}
> async function getCustomLookbackEstimate(connection, serializedTransaction, lookbackSlots = 50) {
>   const response = await fetch(connection.rpcEndpoint, {
>     method: "POST",
>     headers: { "Content-Type": "application/json" },
>     body: JSON.stringify({
>       jsonrpc: "2.0",
>       id: "1",
>       method: "getPriorityFeeEstimate",
>       params: [{
>         transaction: serializedTransaction,
>         options: { 
>           priorityLevel: "Medium",
>           lookbackSlots: lookbackSlots  // 1-150, default is 150
>         }
>       }]
>     })
>   });
>
>   const result = await response.json();
>   return result.result.priorityFeeEstimate;
> }
>
> // Compare different lookback periods
> const recentEstimate = await getCustomLookbackEstimate(connection, serializedTx, 30);
> const longerEstimate = await getCustomLookbackEstimate(connection, serializedTx, 100);
>
> console.log(`Recent (30 slots): ${recentEstimate} micro-lamports`);
> console.log(`Longer (100 slots): ${longerEstimate} micro-lamports`);
> ```

## Best Practices

> [card] Transaction Serialization
>
> **Always serialize your actual transaction**, not a simplified version
>
> ```javascript theme={"system"}
> // ✅ Good - serialize actual transaction
> const transaction = new Transaction();
> transaction.add(actualInstruction1);
> transaction.add(actualInstruction2);
> const serialized = bs58.encode(transaction.serialize());
> ```

> [card] Instruction Order
>
> **Include all instructions except the priority fee** in your estimation transaction
>
> ```javascript theme={"system"}
> // ✅ Good - all business logic included
> transaction.add(createAccountIx);
> transaction.add(initializeIx);
> transaction.add(transferIx);
>
> // ❌ Don't include priority fee in estimation
> ```

## Error Handling Strategies

> [tab] Robust Error Handling
>
> ```javascript theme={"system"}
> class SerializedTransactionFeeEstimator {
>   constructor(connection) {
>     this.connection = connection;
>     this.fallbackFee = 10000; // 10k micro-lamports
>   }
>
>   async getEstimate(serializedTransaction, priorityLevel = "Medium") {
>     try {
>       // Primary attempt with serialized transaction
>       return await this.getPrimaryEstimate(serializedTransaction, priorityLevel);
>     } catch (error) {
>       console.warn("Serialized transaction estimate failed:", error.message);
>
>       // Fallback to account-based estimation
>       try {
>         return await this.getFallbackEstimate(serializedTransaction, priorityLevel);
>       } catch (fallbackError) {
>         console.warn("Fallback estimate failed:", fallbackError.message);
>         return this.getFallbackFee(priorityLevel);
>       }
>     }
>   }
>
>   async getPrimaryEstimate(serializedTransaction, priorityLevel) {
>     const response = await fetch(this.connection.rpcEndpoint, {
>       method: "POST",
>       headers: { "Content-Type": "application/json" },
>       body: JSON.stringify({
>         jsonrpc: "2.0",
>         id: "1",
>         method: "getPriorityFeeEstimate",
>         params: [{
>           transaction: serializedTransaction,
>           options: { 
>             priorityLevel: priorityLevel,
>             recommended: true 
>           }
>         }]
>       })
>     });
>
>     const result = await response.json();
>     if (result.error) {
>       throw new Error(result.error.message);
>     }
>
>     return result.result.priorityFeeEstimate;
>   }
>
>   async getFallbackEstimate(serializedTransaction, priorityLevel) {
>     // Extract account keys from transaction and use account-based estimation
>     const transaction = Transaction.from(bs58.decode(serializedTransaction));
>     const accountKeys = transaction.instructions
>       .flatMap(ix => [ix.programId, ...ix.keys.map(k => k.pubkey)])
>       .map(key => key.toString());
>
>     const uniqueAccountKeys = [...new Set(accountKeys)];
>
>     // Use account-based estimation as fallback
>     const response = await fetch(this.connection.rpcEndpoint, {
>       method: "POST",
>       headers: { "Content-Type": "application/json" },
>       body: JSON.stringify({
>         jsonrpc: "2.0",
>         id: "1",
>         method: "getPriorityFeeEstimate",
>         params: [{
>           accountKeys: uniqueAccountKeys,
>           options: { 
>             priorityLevel: priorityLevel,
>             recommended: true 
>           }
>         }]
>       })
>     });
>
>     const result = await response.json();
>     if (result.error) {
>       throw new Error(result.error.message);
>     }
>
>     return result.result.priorityFeeEstimate;
>   }
>
>   getFallbackFee(priorityLevel) {
>     const fallbacks = {
>       "Low": 1000,
>       "Medium": 5000,
>       "High": 15000,
>       "VeryHigh": 50000
>     };
>
>     return fallbacks[priorityLevel] || 5000;
>   }
> }
>
> // Usage
> const estimator = new SerializedTransactionFeeEstimator(connection);
> const fee = await estimator.getEstimate(serializedTransaction, "High");
> ```

> [tab] Simple Error Handling
>
> ```javascript theme={"system"}
> async function safeGetPriorityFeeEstimate(connection, serializedTransaction, priorityLevel = "Medium") {
>   try {
>     return await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
>   } catch (error) {
>     console.warn(`Priority fee estimation failed: ${error.message}`);
>
>     // Extract account keys and fall back to account-based estimation
>     try {
>       const transaction = Transaction.from(bs58.decode(serializedTransaction));
>       const accountKeys = transaction.instructions
>         .flatMap(ix => [ix.programId, ...ix.keys.map(k => k.pubkey)])
>         .map(key => key.toString());
>
>       const uniqueAccountKeys = [...new Set(accountKeys)];
>       return await getAccountBasedEstimate(connection, uniqueAccountKeys, priorityLevel);
>     } catch (fallbackError) {
>       console.warn(`Fallback estimation failed: ${fallbackError.message}`);
>
>       // Return reasonable fallback based on priority level
>       const fallbacks = {
>         "Low": 1000,
>         "Medium": 5000,
>         "High": 15000,
>         "VeryHigh": 50000
>       };
>
>       return fallbacks[priorityLevel] || 5000;
>     }
>   }
> }
> ```

## Common Issues & Solutions

> [accordion] Transaction Serialization Errors
>
> **Problem**: Error serializing incomplete transactions
>
> **Solution**: Always set required fields before serialization:
>
> ```javascript theme={"system"}
> // ✅ Always set these fields
> transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
> transaction.feePayer = keypair.publicKey;
>
> // Then serialize
> const serialized = bs58.encode(transaction.serialize());
> ```

> [accordion] Stale Blockhash Issues
>
> **Problem**: Using stale blockhash causes transaction failures
>
> **Solution**: Always get fresh blockhash before final send:
>
> ```javascript theme={"system"}
> // Get estimate with temporary blockhash
> const tempBlockhash = (await connection.getLatestBlockhash()).blockhash;
> transaction.recentBlockhash = tempBlockhash;
> const serialized = bs58.encode(transaction.serialize());
>
> const priorityFee = await getPriorityFeeEstimate(connection, serialized, "Medium");
>
> // Reset and rebuild with fresh blockhash
> transaction.instructions = [];
> transaction.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }));
> transaction.add(originalInstruction);
>
> // Get FRESH blockhash before sending
> const freshBlockhash = (await connection.getLatestBlockhash()).blockhash;
> transaction.recentBlockhash = freshBlockhash;
> ```

> [accordion] Large Transaction Errors
>
> **Problem**: Transaction too large for serialization
>
> **Solution**: Use versioned transactions or break into multiple transactions:
>
> ```javascript theme={"system"}
> import { VersionedTransaction, TransactionMessage } from "@solana/web3.js";
>
> // For large transactions, use versioned transactions
> const messageV0 = new TransactionMessage({
>   payerKey: keypair.publicKey,
>   recentBlockhash: (await connection.getLatestBlockhash()).blockhash,
>   instructions: [instruction1, instruction2, instruction3] // Many instructions
> }).compileToV0Message();
>
> const versionedTransaction = new VersionedTransaction(messageV0);
> const serialized = bs58.encode(versionedTransaction.serialize());
> ```

## When to Use vs Account Keys

> [card] Use Serialized Transactions
>
> **Production applications**
>
> * Maximum accuracy required
> * Complex multi-instruction transactions
> * Critical operations
> * Performance-sensitive applications
>
> **Development scenarios**
>
> * Final integration testing
> * Performance optimization
> * Production deployment

> [card] Use Account Keys
>
> **Development & prototyping**
>
> * Quick estimates during development
> * Simple transactions
> * Pre-transaction planning
> * Architecture constraints preventing serialization
>
> **Analysis scenarios**
>
> * Account-level fee pattern analysis
> * Batch account analysis
> * Quick market research

## Related Resources

> [card] [Account Keys Method](https://www.helius.dev/docs/priority-fee/estimating-fees-using-account-keys.md)
>
> Advanced method using account keys for specialized use cases

> [card] [API Reference](https://www.helius.dev/docs/api-reference/priority-fee/getpriorityfeeestimate.md)
>
> Complete API documentation and parameters


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.