getTransaction

Parameters

string

required

Transaction signature (base-58 encoded)

object

Configuration object containing:

string

Commitment level (processed, confirmed, finalized)

string

Encoding for transaction data (base58, base64, jsonParsed)

number

Maximum transaction version to support

Response

object

Object containing:

number

The slot the transaction was processed in

object

number

Number of required signatures

number

Number of read-only signed accounts

number

Number of read-only unsigned accounts

array

Array of account public keys (base-58 encoded)

string

Recent blockhash used for transaction

array

Array of instruction objects containing:

string

Program ID (base-58 encoded)

array

Array of account indices

string

Instruction data (base-58 encoded)

array

Array of transaction signatures (base-58 encoded)

object

Error object if transaction failed

number

Fee paid for the transaction

array

Array of account balances before the transaction

array

Array of account balances after the transaction

array

Array of inner instruction objects

array

Array of log messages

array

Array of token balances before the transaction

array

Array of token balances after the transaction

array

Array of reward objects

Code Examples

Basic Request

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

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

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

Best Practices

Use appropriate commitment level based on your needs
Cache results when appropriate to reduce RPC load
Monitor for transaction status changes
Consider using websocket subscription for real-time updates
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

Transaction Analysis

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

Transaction Monitoring

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

Transaction Planning

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()
      }
    };
  }
}

Get Started

Agents

Products

Solutions

Fetching Data

RPC

Data Streaming

Trading APIs

Parameters

Response

Code Examples

Basic Request

Using web3.js

Notes

Best Practices

Common Errors

Use Cases

​Parameters

​Response

​Code Examples

​Basic Request

​Using web3.js

​Notes

​Best Practices

​Common Errors

​Use Cases

Parameters

Response

Code Examples

Basic Request

Using web3.js

Notes

Best Practices

Common Errors

Use Cases