getTransactionsForAddress

Overview

getTransactionsForAddress combines transaction signature lookup and full transaction retrieval into one efficient call. Instead of making separate requests to getSignaturesForAddress and then getTransaction for each signature, you get everything in a single request. This method supports:

Bidirectional sorting (oldest-first or newest-first)
Time and slot-based filtering via range operators
Transaction status filtering (succeeded/failed)
Token account filtering (none, balanceChanged, all)
Cursor-based pagination via paginationToken
Four detail levels: signatures, none, accounts, full

Why Use This Method

The N+1 Problem

With standard Solana RPC methods, fetching transaction history requires multiple calls:

Call getSignaturesForAddress to get a list of transaction signatures
Call getTransaction for each signature to get full transaction data

For a wallet with 100 transactions, that’s 101 API calls. For 1,000 transactions, it’s 1,001 calls. This creates latency, complexity, and higher costs. getTransactionsForAddress solves this by returning full transaction data in a single call—up to 100 complete transactions or 1,000 signatures per request.

Additional Capabilities

Beyond efficiency, this method provides features not available in standard RPC:

Bidirectional sorting: Query oldest-first (asc) to trace an address from its first transaction
Time-based filtering: Retrieve transactions within a specific date range using filters.blockTime with range operators
Slot-based filtering: Query transactions from specific block ranges using filters.slot with range operators
Status filtering: Get only successful or only failed transactions
Token account inclusion: Capture transactions from associated token accounts

Token Account Support

Standard getSignaturesForAddress only returns transactions that directly reference the queried address. This misses an important category: token transfers. When tokens are sent to a wallet, the transaction references the wallet’s Associated Token Account (ATA), not the wallet address itself. This means standard methods give you an incomplete picture. getTransactionsForAddress with tokenAccounts: "all" automatically includes transactions from all token accounts owned by the address, giving you complete transaction history.

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": "getTransactionsForAddress",
  "params": [
    "WALLET_ADDRESS",
    {
      "filters": {
        "tokenAccounts": "all"
      }
    }
  ]
}'

Set tokenAccounts: "none" (the default) if you only want transactions that directly reference the address.

Parameters

address

string

обязательно

The Solana address to query (base-58 encoded public key, 32 bytes)

options

object

Показать options fields

transactionDetails

string

Level of detail to return:

"signatures" - Signature info with memo and status (up to 1000 results). Default.
"none" - Same fields as signatures (up to 1000 results)
"accounts" - Signature info plus account keys (up to 100 results)
"full" - Complete transaction data (up to 100 results)

Default: "signatures"

sortOrder

string

Sort direction:

"desc" - Newest transactions first (default)
"asc" - Oldest transactions first

limit

number

Maximum number of results to return.

For transactionDetails: "signatures" or "none": max 1000
For transactionDetails: "full" or "accounts": max 100

Default: 100

paginationToken

string

Pagination cursor from a previous response. Format: "slot:txIndex" (e.g. "387936002:541").

commitment

string

The commitment level for the query:

"finalized" - Query finalized blocks only (default)
"confirmed" - Query confirmed blocks

Note: "processed" is not supported and returns an error.

encoding

string

Encoding format for transaction data (only applies when transactionDetails: "full"):

"json" (default)
"jsonParsed"
"base64"
"base58"

maxSupportedTransactionVersion

number

Maximum transaction version to return. In "full" mode this defaults to 0 (includes versioned transactions). Set explicitly if you need legacy-only behavior.

minContextSlot

number

The minimum slot that the request can be evaluated at.

filters

object

Показать filter fields

tokenAccounts

string

Filter by token account association:

"none" - Only transactions that directly reference the address. Default.
"balanceChanged" - Include token account transactions where balance changed (recommended for clean wallet history)
"all" - Include all token account transactions

Default: "none"

blockTime

object

Filter by Unix timestamp using range operators: gte, gt, lte, lt, eqExample: { "blockTime": { "gte": 1704067200, "lte": 1706745600 } }

slot

object

Filter by slot number using range operators: gte, gt, lte, lt, eqExample: { "slot": { "gte": 387000000, "lte": 388000000 } }

signature

object

Filter by transaction signature (base-58, 64 bytes) using range operators: gte, gt, lte, ltExample: { "signature": { "lt": "5abc..." } }

status

string

Filter by transaction status:

"succeeded" - Only successful transactions
"failed" - Only failed transactions
Omit or use any other value for no status filter

Response

The response result is an object containing a data array and an optional paginationToken:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "data": [ ... ],
    "paginationToken": "387936002:541"
  }
}

The paginationToken is only present when more results are available. Pass it in the next request to fetch the next page.

With `transactionDetails: "signatures"` or `"none"`

result.data[]

object

Показать signature fields

signature

string

Transaction signature (base-58 encoded)

slot

number

Slot in which the transaction was processed

transactionIndex

number

Zero-based index of the transaction within the block

blockTime

number | null

Unix timestamp of the block

err

object | null

Error object if transaction failed, null otherwise

memo

string | null

Memo text if the transaction includes a Memo program instruction

confirmationStatus

string

Echoes the requested commitment level ("finalized" or "confirmed")

With `transactionDetails: "accounts"`

Same fields as signatures mode, plus:

accountKeys

string[]

Array of base-58 public keys involved in the transaction, including addresses loaded from lookup tables.

With `transactionDetails: "full"`

result.data[]

object

Показать transaction fields

slot

number

Slot in which the transaction was processed

transactionIndex

number

Zero-based index of the transaction within the block. This field is unique to getTransactionsForAddress.

blockTime

number | null

Unix timestamp of the block

transaction

object

Full transaction data including message, signatures, and metadata (format depends on encoding)

Code Examples

Basic Request

Get the most recent signatures for an address (default mode):

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": "getTransactionsForAddress",
  "params": [
    "ADDRESS_HERE"
  ]
}'

Get Full Transactions

Retrieve up to 100 full transactions:

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": "getTransactionsForAddress",
  "params": [
    "ADDRESS_HERE",
    {
      "transactionDetails": "full",
      "limit": 100
    }
  ]
}'

Get Signatures Only

Retrieve up to 1000 signatures without full transaction data:

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": "getTransactionsForAddress",
  "params": [
    "ADDRESS_HERE",
    {
      "transactionDetails": "signatures",
      "limit": 1000
    }
  ]
}'

Oldest-First with Time Filter

Get transactions from a specific time range, sorted oldest first:

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": "getTransactionsForAddress",
  "params": [
    "ADDRESS_HERE",
    {
      "sortOrder": "asc",
      "filters": {
        "blockTime": {
          "gte": 1704067200,
          "lte": 1706745600
        }
      }
    }
  ]
}'

Successful Transactions Only

Filter to only return transactions that succeeded:

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": "getTransactionsForAddress",
  "params": [
    "ADDRESS_HERE",
    {
      "filters": {
        "status": "succeeded"
      }
    }
  ]
}'

Paginated Request

Use cursor-based pagination to fetch more results:

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": "getTransactionsForAddress",
  "params": [
    "ADDRESS_HERE",
    {
      "limit": 100,
      "paginationToken": "387936002:541"
    }
  ]
}'

TypeScript Example

interface GetTransactionsOptions {
  transactionDetails?: 'full' | 'signatures' | 'accounts' | 'none';
  limit?: number;
  sortOrder?: 'asc' | 'desc';
  paginationToken?: string;
  commitment?: 'finalized' | 'confirmed';
  encoding?: 'json' | 'jsonParsed' | 'base64' | 'base58';
  maxSupportedTransactionVersion?: number;
  minContextSlot?: number;
  filters?: {
    tokenAccounts?: 'none' | 'balanceChanged' | 'all';
    blockTime?: { gte?: number; gt?: number; lte?: number; lt?: number; eq?: number };
    slot?: { gte?: number; gt?: number; lte?: number; lt?: number; eq?: number };
    signature?: { gte?: string; gt?: string; lte?: string; lt?: string };
    status?: 'succeeded' | 'failed';
  };
}

interface GtfaResult {
  data: any[];
  paginationToken?: string;
}

async function getTransactionsForAddress(
  address: string,
  options: GetTransactionsOptions = {}
): Promise<GtfaResult> {
  const response = await fetch('https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'getTransactionsForAddress',
      params: [address, options],
    }),
  });

  const data = await response.json();
  return data.result;
}

// Get recent signatures (default mode)
const recent = await getTransactionsForAddress('ADDRESS_HERE');
console.log(recent.data);

// Get oldest transactions first with time filter
const historical = await getTransactionsForAddress('ADDRESS_HERE', {
  sortOrder: 'asc',
  filters: {
    blockTime: {
      gte: Math.floor(Date.now() / 1000) - 86400 * 30,
    },
  },
});

// Paginate through all signatures
async function getAllSignatures(address: string) {
  const allSignatures: any[] = [];
  let paginationToken: string | undefined;

  while (true) {
    const result = await getTransactionsForAddress(address, {
      transactionDetails: 'signatures',
      limit: 1000,
      paginationToken,
    });

    if (!result.data || result.data.length === 0) break;

    allSignatures.push(...result.data);
    paginationToken = result.paginationToken;

    if (!paginationToken) break;
  }

  return allSignatures;
}

Use Cases

Token Launch Analysis

Find the earliest transactions for a token mint to identify first minters and early holders. Use sortOrder: "asc" to start from the beginning:

const earlyActivity = await getTransactionsForAddress(tokenMintAddress, {
  sortOrder: 'asc',
  limit: 100,
  transactionDetails: 'full',
  filters: {
    tokenAccounts: 'all',
  },
});

Wallet Funding History

Trace where a wallet’s funds originated by querying its complete transaction history:

const fundingHistory = await getTransactionsForAddress(walletAddress, {
  sortOrder: 'asc',
  transactionDetails: 'full',
  filters: {
    tokenAccounts: 'all',
  },
});

const firstTransactions = fundingHistory.data.slice(0, 10);

Failed Transaction Analysis

Debug transaction failures by filtering to only failed transactions:

const result = await getTransactionsForAddress(walletAddress, {
  filters: {
    status: 'failed',
  },
  transactionDetails: 'full',
});

result.data.forEach(tx => {
  console.log(tx.meta?.err, tx.meta?.logMessages);
});

Build a Wallet Transaction Feed

Create a paginated transaction history for a wallet UI:

async function getWalletFeed(wallet: string, cursor?: string) {
  return getTransactionsForAddress(wallet, {
    limit: 20,
    paginationToken: cursor,
    transactionDetails: 'full',
    filters: {
      tokenAccounts: 'balanceChanged',
    },
  });
}

Trading Pattern Analysis

Filter successful trades within a specific time window:

const trades = await getTransactionsForAddress(traderWallet, {
  filters: {
    status: 'succeeded',
    blockTime: {
      gte: startOfMonth,
      lt: endOfMonth,
    },
  },
  transactionDetails: 'full',
});

Compliance Audit

Build a complete transaction history for regulatory compliance:

async function auditAddress(address: string) {
  const allTxs = await getAllSignatures(address);

  return {
    totalTransactions: allTxs.length,
    successful: allTxs.filter(tx => !tx.err).length,
    failed: allTxs.filter(tx => tx.err).length,
    firstTransaction: allTxs[allTxs.length - 1],
    lastTransaction: allTxs[0],
  };
}

Pagination

For addresses with many transactions, use the paginationToken from the response to fetch the next page. The token is a string in the format "slot:txIndex" that tells the server where to continue from.

Fetching Newer Transactions (Default)

With sortOrder: "desc" (default), transactions are returned newest-first. The paginationToken continues to older transactions:

const page1 = await getTransactionsForAddress(address, { limit: 100 });

if (page1.paginationToken) {
  const page2 = await getTransactionsForAddress(address, {
    limit: 100,
    paginationToken: page1.paginationToken,
  });
}

Fetching Older Transactions First

With sortOrder: "asc", transactions are returned oldest-first. The paginationToken continues to newer transactions:

const page1 = await getTransactionsForAddress(address, {
  sortOrder: 'asc',
  limit: 100,
});

if (page1.paginationToken) {
  const page2 = await getTransactionsForAddress(address, {
    sortOrder: 'asc',
    limit: 100,
    paginationToken: page1.paginationToken,
  });
}

Complete Pagination Example

Fetch all signatures for an address:

async function getAllSignatures(address: string) {
  const allSignatures: any[] = [];
  let paginationToken: string | undefined;

  while (true) {
    const result = await getTransactionsForAddress(address, {
      transactionDetails: 'signatures',
      limit: 1000,
      paginationToken,
    });

    if (!result.data || result.data.length === 0) break;

    allSignatures.push(...result.data);
    paginationToken = result.paginationToken;

    if (!paginationToken) break;

    await new Promise(resolve => setTimeout(resolve, 100));
  }

  return allSignatures;
}

Best Practices

Use signatures mode for counting: When you only need to count or list transactions, use transactionDetails: "signatures" (the default) for better performance and higher limits (up to 1000).
Filter early: Apply blockTime, slot, or status filters to reduce the amount of data scanned and improve response times.
Implement pagination: For addresses with many transactions, always paginate using the paginationToken from the response.
Cache results: Transaction data is immutable once finalized. Cache historical results to avoid redundant requests.
Handle rate limits: Implement exponential backoff when making many sequential requests.

Common Errors

Code	Message	Solution
-32602	Invalid params	Verify address format (base-58, 32 bytes) and option values
-32602	Invalid paginationToken format	Ensure token is in `"slot:txIndex"` format from a previous response
-32602	commitment must be ‘finalized’ or ‘confirmed’	Do not use `"processed"` commitment
-32603	Internal error	Database or encoding failure; retry the request

Comparison with Standard Methods

Feature	getSignaturesForAddress + getTransaction	getTransactionsForAddress
API calls	Multiple (1 + N)	Single
Sorting	Newest first only	Bidirectional
Time filtering	Not supported	Supported via `filters.blockTime`
Slot filtering	Not supported	Supported via `filters.slot`
Status filtering	Not supported	Supported via `filters.status`
Token accounts	Manual ATA queries	Built-in via `filters.tokenAccounts`
Max signatures	1000 per call	1000 per call
Max full transactions	Limited by calls	100 per call
Pagination	Signature-based `before`/`until`	Cursor-based `paginationToken`

​Overview

​Why Use This Method

​The N+1 Problem

​Additional Capabilities

​Token Account Support

​Parameters

​Response

​With transactionDetails: "signatures" or "none"

​With transactionDetails: "accounts"

​With transactionDetails: "full"

​Code Examples

​Basic Request

​Get Full Transactions

​Get Signatures Only

​Oldest-First with Time Filter

​Successful Transactions Only

​Paginated Request

​TypeScript Example

​Use Cases

​Token Launch Analysis

​Wallet Funding History

​Failed Transaction Analysis

​Build a Wallet Transaction Feed

​Trading Pattern Analysis

​Compliance Audit

​Pagination

​Fetching Newer Transactions (Default)

​Fetching Older Transactions First

​Complete Pagination Example

​Best Practices

​Common Errors

​Comparison with Standard Methods

Overview

Why Use This Method

The N+1 Problem

Additional Capabilities

Token Account Support

Parameters

Response

With `transactionDetails: "signatures"` or `"none"`

With `transactionDetails: "accounts"`

With `transactionDetails: "full"`

Code Examples

Basic Request

Get Full Transactions

Get Signatures Only

Oldest-First with Time Filter

Successful Transactions Only

Paginated Request

TypeScript Example

Use Cases

Token Launch Analysis

Wallet Funding History

Failed Transaction Analysis

Build a Wallet Transaction Feed

Trading Pattern Analysis

Compliance Audit

Pagination

Fetching Newer Transactions (Default)

Fetching Older Transactions First

Complete Pagination Example

Best Practices

Common Errors

Comparison with Standard Methods