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

# getTransaction

> Returns transaction details for a given signature

## Parameters

<ResponseField name="signature" type="string" required>
  Transaction signature (base-58 encoded)
</ResponseField>

<ResponseField name="config" type="object" optional>
  Configuration object containing:

  <ResponseField name="commitment" type="string" optional>
    Commitment level (processed, confirmed, finalized)
  </ResponseField>

  <ResponseField name="encoding" type="string" optional>
    Encoding for transaction data (base58, base64, jsonParsed)
  </ResponseField>

  <ResponseField name="maxSupportedTransactionVersion" type="number" optional>
    Maximum transaction version to support
  </ResponseField>
</ResponseField>

## Response

<ResponseField name="result" type="object">
  Object containing:

  <ResponseField name="slot" type="number">
    The slot the transaction was processed in
  </ResponseField>

  <ResponseField name="transaction" type="object">
    <ResponseField name="message" type="object">
      <ResponseField name="header" type="object">
        <ResponseField name="numRequiredSignatures" type="number">
          Number of required signatures
        </ResponseField>

        <ResponseField name="numReadonlySignedAccounts" type="number">
          Number of read-only signed accounts
        </ResponseField>

        <ResponseField name="numReadonlyUnsignedAccounts" type="number">
          Number of read-only unsigned accounts
        </ResponseField>
      </ResponseField>

      <ResponseField name="accountKeys" type="array">
        Array of account public keys (base-58 encoded)
      </ResponseField>

      <ResponseField name="recentBlockhash" type="string">
        Recent blockhash used for transaction
      </ResponseField>

      <ResponseField name="instructions" type="array">
        Array of instruction objects containing:

        <ResponseField name="programId" type="string">
          Program ID (base-58 encoded)
        </ResponseField>

        <ResponseField name="accounts" type="array">
          Array of account indices
        </ResponseField>

        <ResponseField name="data" type="string">
          Instruction data (base-58 encoded)
        </ResponseField>
      </ResponseField>
    </ResponseField>

    <ResponseField name="signatures" type="array">
      Array of transaction signatures (base-58 encoded)
    </ResponseField>
  </ResponseField>

  <ResponseField name="meta" type="object">
    <ResponseField name="err" type="object" optional>
      Error object if transaction failed
    </ResponseField>

    <ResponseField name="fee" type="number">
      Fee paid for the transaction
    </ResponseField>

    <ResponseField name="preBalances" type="array">
      Array of account balances before the transaction
    </ResponseField>

    <ResponseField name="postBalances" type="array">
      Array of account balances after the transaction
    </ResponseField>

    <ResponseField name="innerInstructions" type="array" optional>
      Array of inner instruction objects
    </ResponseField>

    <ResponseField name="logMessages" type="array" optional>
      Array of log messages
    </ResponseField>

    <ResponseField name="preTokenBalances" type="array" optional>
      Array of token balances before the transaction
    </ResponseField>

    <ResponseField name="postTokenBalances" type="array" optional>
      Array of token balances after the transaction
    </ResponseField>

    <ResponseField name="rewards" type="array" optional>
      Array of reward objects
    </ResponseField>
  </ResponseField>
</ResponseField>

## Code Examples

### Basic Request

```bash theme={null}
curl https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY -X POST -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransaction",
  "params": [
    "5VERv8NMvzbJMEkV8xnrLkUaQwJJ9C9zV5uZ6cKf7Kq9",
    {
      "encoding": "jsonParsed"
    }
  ]
}'
```

### Using web3.js

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

const connection = new Connection('https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY');

// Get transaction
const signature = '5VERv8NMvzbJMEkV8xnrLkUaQwJJ9C9zV5uZ6cKf7Kq9';
const transaction = await connection.getTransaction(signature, {
  encoding: 'jsonParsed'
});
console.log('Transaction:', transaction);

// Get transaction with analysis
async function getTransactionWithAnalysis(
  signature: string,
  config: { commitment?: string; encoding?: string }
) {
  const transaction = await connection.getTransaction(signature, config);
  
  return {
    transaction,
    analysis: {
      success: !transaction.meta.err,
      fee: transaction.meta.fee,
      balanceChanges: transaction.meta.postBalances.map((post, index) => ({
        account: transaction.transaction.message.accountKeys[index],
        change: post - transaction.meta.preBalances[index]
      })),
      tokenBalanceChanges: transaction.meta.postTokenBalances?.map((post, index) => ({
        account: post.account,
        mint: post.mint,
        change: BigInt(post.uiTokenAmount.amount) - BigInt(transaction.meta.preTokenBalances![index].uiTokenAmount.amount)
      })),
      metadata: {
        timestamp: Date.now(),
        commitment: config.commitment
      }
    }
  };
}
```

## Notes

1. Returns transaction details for a given signature
2. The transaction must be confirmed to be returned
3. The response includes detailed information about the transaction
4. The transaction can be parsed in different encodings
5. The transaction must be a valid signature

## Best Practices

1. Use appropriate commitment level based on your needs
2. Cache results when appropriate to reduce RPC load
3. Monitor for transaction status changes
4. Consider using websocket subscription for real-time updates
5. Handle network errors and retry when appropriate

## Common Errors

| Code   | Message               | Solution                                     |
| ------ | --------------------- | -------------------------------------------- |
| -32601 | Method not found      | Verify you're connected to a Solana RPC node |
| -32602 | Invalid params        | Check signature and configuration            |
| -32007 | Transaction not found | Verify the transaction exists                |
| -32008 | Invalid encoding      | Ensure encoding is valid                     |

## Use Cases

1. **Transaction Analysis**
   ```typescript theme={null}
   interface TransactionAnalysis {
     signature: string;
     transaction: {
       success: boolean;
       fee: number;
       balanceChanges: Array<{
         account: string;
         change: number;
       }>;
       tokenBalanceChanges?: Array<{
         account: string;
         mint: string;
         change: bigint;
       }>;
       instructions: Array<{
         programId: string;
         accounts: string[];
         data: string;
       }>;
     };
     metrics: {
       totalBalanceChange: number;
       totalTokenBalanceChange?: bigint;
       instructionCount: number;
       accountCount: number;
     };
     metadata: {
       timestamp: number;
       commitment?: string;
     };
   }

   class TransactionAnalyzer {
     async analyzeTransaction(
       signature: string,
       config: { commitment?: string; encoding?: string }
     ): Promise<TransactionAnalysis> {
       const transaction = await connection.getTransaction(signature, config);
       
       return {
         signature,
         transaction: {
           success: !transaction.meta.err,
           fee: transaction.meta.fee,
           balanceChanges: transaction.meta.postBalances.map((post, index) => ({
             account: transaction.transaction.message.accountKeys[index],
             change: post - transaction.meta.preBalances[index]
           })),
           tokenBalanceChanges: transaction.meta.postTokenBalances?.map((post, index) => ({
             account: post.account,
             mint: post.mint,
             change: BigInt(post.uiTokenAmount.amount) - BigInt(transaction.meta.preTokenBalances![index].uiTokenAmount.amount)
           })),
           instructions: transaction.transaction.message.instructions.map(ix => ({
             programId: transaction.transaction.message.accountKeys[ix.programIdIndex],
             accounts: ix.accounts.map(index => transaction.transaction.message.accountKeys[index]),
             data: ix.data
           }))
         },
         metrics: {
           totalBalanceChange: transaction.meta.postBalances.reduce((sum, post, index) => 
             sum + (post - transaction.meta.preBalances[index]), 0),
           totalTokenBalanceChange: transaction.meta.postTokenBalances?.reduce((sum, post, index) => 
             sum + (BigInt(post.uiTokenAmount.amount) - BigInt(transaction.meta.preTokenBalances![index].uiTokenAmount.amount)), BigInt(0)),
           instructionCount: transaction.transaction.message.instructions.length,
           accountCount: transaction.transaction.message.accountKeys.length
         },
         metadata: {
           timestamp: Date.now(),
           commitment: config.commitment
         }
       };
     }
   }
   ```

2. **Transaction Monitoring**
   ```typescript theme={null}
   interface TransactionChange {
     signature: string;
     changes: {
       status: 'confirmed' | 'failed' | 'dropped';
       previousStatus?: 'confirmed' | 'failed' | 'dropped';
       error?: any;
     };
     metadata: {
       timestamp: number;
     };
   }

   class TransactionMonitor {
     private previousTransactions: Map<string, {
       status: 'confirmed' | 'failed' | 'dropped';
       error?: any;
     }> = new Map();
     
     async monitorTransaction(
       signature: string,
       config: { commitment?: string; encoding?: string }
     ): Promise<TransactionChange | null> {
       const transaction = await connection.getTransaction(signature, config);
       const currentStatus = transaction ? (transaction.meta.err ? 'failed' : 'confirmed') : 'dropped';
       const previous = this.previousTransactions.get(signature);
       
       if (previous && (previous.status !== currentStatus || previous.error !== transaction?.meta.err)) {
         this.previousTransactions.set(signature, {
           status: currentStatus,
           error: transaction?.meta.err
         });
         
         return {
           signature,
           changes: {
             status: currentStatus,
             previousStatus: previous.status,
             error: transaction?.meta.err
           },
           metadata: {
             timestamp: Date.now()
           }
         };
       }
       
       this.previousTransactions.set(signature, {
         status: currentStatus,
         error: transaction?.meta.err
       });
       return null;
     }
   }
   ```

3. **Transaction Planning**
   ```typescript theme={null}
   interface TransactionPlan {
     signature: string;
     transaction: {
       success: boolean;
       fee: number;
       balanceChanges: Array<{
         account: string;
         change: number;
       }>;
       tokenBalanceChanges?: Array<{
         account: string;
         mint: string;
         change: bigint;
       }>;
     };
     recommendations: Array<{
       type: 'optimize' | 'retry' | 'cancel';
       reason: string;
     }>;
     metadata: {
       timestamp: number;
     };
   }

   class TransactionPlanner {
     private readonly maxFee = 1000000; // 0.001 SOL
     private readonly minBalance = 1000000; // 0.001 SOL
     
     async planTransaction(
       signature: string,
       config: { commitment?: string; encoding?: string }
     ): Promise<TransactionPlan> {
       const transaction = await connection.getTransaction(signature, config);
       
       const recommendations: Array<{
         type: 'optimize' | 'retry' | 'cancel';
         reason: string;
       }> = [];
       
       // Check for high fees
       if (transaction.meta.fee > this.maxFee) {
         recommendations.push({
           type: 'optimize',
           reason: `Transaction fee (${transaction.meta.fee}) exceeds maximum (${this.maxFee})`
         });
       }
       
       // Check for low balances
       const lowBalanceAccounts = transaction.meta.postBalances
         .map((post, index) => ({
           account: transaction.transaction.message.accountKeys[index],
           balance: post
         }))
         .filter(acc => acc.balance < this.minBalance);
       
       if (lowBalanceAccounts.length > 0) {
         recommendations.push({
           type: 'optimize',
           reason: `Accounts with low balances: ${lowBalanceAccounts.map(acc => acc.account).join(', ')}`
         });
       }
       
       // Check for failed transaction
       if (transaction.meta.err) {
         recommendations.push({
           type: 'retry',
           reason: `Transaction failed with error: ${JSON.stringify(transaction.meta.err)}`
         });
       }
       
       return {
         signature,
         transaction: {
           success: !transaction.meta.err,
           fee: transaction.meta.fee,
           balanceChanges: transaction.meta.postBalances.map((post, index) => ({
             account: transaction.transaction.message.accountKeys[index],
             change: post - transaction.meta.preBalances[index]
           })),
           tokenBalanceChanges: transaction.meta.postTokenBalances?.map((post, index) => ({
             account: post.account,
             mint: post.mint,
             change: BigInt(post.uiTokenAmount.amount) - BigInt(transaction.meta.preTokenBalances![index].uiTokenAmount.amount)
           }))
         },
         recommendations,
         metadata: {
           timestamp: Date.now()
         }
       };
     }
   }
   ```