> ## 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.

# getSignaturesForAddress

> Returns signatures for confirmed transactions for an address

## Parameters

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

<ResponseField name="config" type="object" optional>
  <Expandable title="config fields">
    <ResponseField name="limit" type="number" optional>
      Maximum number of signatures to return (default: 1000)
    </ResponseField>

    <ResponseField name="before" type="string" optional>
      Start searching backwards from this signature
    </ResponseField>

    <ResponseField name="until" type="string" optional>
      Search until this signature
    </ResponseField>

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

## Response

<ResponseField name="result" type="array">
  Array of signature information objects

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

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

  <ResponseField name="err" type="object" optional>
    Error if transaction failed, null if transaction succeeded
  </ResponseField>

  <ResponseField name="memo" type="string" optional>
    Memo associated with the transaction
  </ResponseField>

  <ResponseField name="blockTime" type="number" optional>
    Unix timestamp of when the transaction was processed
  </ResponseField>

  <ResponseField name="confirmationStatus" type="string" optional>
    Transaction confirmation status
  </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": "getSignaturesForAddress",
  "params": [
    "ADDRESS"
  ]
}'
```

### Request with Config

```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": "getSignaturesForAddress",
  "params": [
    "ADDRESS",
    {
      "limit": 100,
      "before": "SIGNATURE",
      "commitment": "confirmed"
    }
  ]
}'
```

### Using web3.js

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

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

// Get signatures for address
const signatures = await connection.getSignaturesForAddress(
  new PublicKey('ADDRESS')
);
console.log('Signatures:', signatures);

// Get paginated signatures
async function getPaginatedSignatures(
  address: PublicKey,
  limit: number = 100,
  before?: string
) {
  const signatures = await connection.getSignaturesForAddress(address, {
    limit,
    before
  });
  
  return signatures.map(signature => ({
    signature: signature.signature,
    slot: signature.slot,
    success: !signature.err,
    timestamp: signature.blockTime,
    status: signature.confirmationStatus
  }));
}
```

## Notes

1. Returns confirmed transaction signatures for an address
2. Results are returned in reverse chronological order
3. Pagination can be achieved using the `before` parameter
4. The response is immediate as it reads from the current state
5. Different commitment levels can be specified

## Best Practices

1. Use appropriate limit based on your needs
2. Implement pagination for large result sets
3. Cache results when appropriate to reduce RPC load
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 address and config parameters          |
| -32007 | Signature information unavailable | Node may be bootstrapping or syncing         |

## Use Cases

1. **Transaction History**
   ```typescript theme={null}
   interface TransactionHistory {
     transactions: Array<{
       signature: string;
       slot: number;
       success: boolean;
       timestamp: number;
       status: string;
     }>;
     metadata: {
       total: number;
       startTime: number;
       endTime: number;
     };
   }

   async function getTransactionHistory(
     address: PublicKey,
     limit: number = 100
   ): Promise<TransactionHistory> {
     const signatures = await connection.getSignaturesForAddress(address, {
       limit
     });
     
     return {
       transactions: signatures.map(signature => ({
         signature: signature.signature,
         slot: signature.slot,
         success: !signature.err,
         timestamp: signature.blockTime || 0,
         status: signature.confirmationStatus || 'unknown'
       })),
       metadata: {
         total: signatures.length,
         startTime: signatures[0]?.blockTime || 0,
         endTime: signatures[signatures.length - 1]?.blockTime || 0
       }
     };
   }
   ```

2. **Transaction Monitoring**
   ```typescript theme={null}
   interface TransactionAlert {
     type: 'new' | 'failed' | 'status_change';
     signature: string;
     previousStatus: string | null;
     currentStatus: string;
     metadata: {
       timestamp: number;
       slot: number;
     };
   }

   class TransactionMonitor {
     private previousSignatures: Map<string, any> = new Map();
     
     async monitorTransactions(
       address: PublicKey,
       interval: number = 5000
     ): Promise<TransactionAlert[]> {
       const signatures = await connection.getSignaturesForAddress(address, {
         limit: 10
       });
       const alerts: TransactionAlert[] = [];
       
       signatures.forEach(signature => {
         const previous = this.previousSignatures.get(signature.signature);
         
         if (!previous) {
           alerts.push({
             type: 'new',
             signature: signature.signature,
             previousStatus: null,
             currentStatus: signature.confirmationStatus || 'unknown',
             metadata: {
               timestamp: Date.now(),
               slot: signature.slot
             }
           });
         } else if (previous.confirmationStatus !== signature.confirmationStatus) {
           alerts.push({
             type: 'status_change',
             signature: signature.signature,
             previousStatus: previous.confirmationStatus,
             currentStatus: signature.confirmationStatus || 'unknown',
             metadata: {
               timestamp: Date.now(),
               slot: signature.slot
             }
           });
         }
         
         this.previousSignatures.set(signature.signature, signature);
       });
       
       return alerts;
     }
   }
   ```

3. **Transaction Analysis**
   ```typescript theme={null}
   interface TransactionAnalysis {
     total: number;
     successful: number;
     failed: number;
     statusDistribution: Record<string, number>;
     timeDistribution: {
       hourly: Record<number, number>;
       daily: Record<number, number>;
     };
     metadata: {
       startTime: number;
       endTime: number;
       duration: number;
     };
   }

   async function analyzeTransactions(
     address: PublicKey,
     limit: number = 1000
   ): Promise<TransactionAnalysis> {
     const signatures = await connection.getSignaturesForAddress(address, {
       limit
     });
     
     const statusDistribution: Record<string, number> = {};
     const hourlyDistribution: Record<number, number> = {};
     const dailyDistribution: Record<number, number> = {};
     
     let successful = 0;
     let failed = 0;
     
     signatures.forEach(signature => {
       const status = signature.confirmationStatus || 'unknown';
       statusDistribution[status] = (statusDistribution[status] || 0) + 1;
       
       if (signature.err) {
         failed++;
       } else {
         successful++;
       }
       
       if (signature.blockTime) {
         const date = new Date(signature.blockTime * 1000);
         const hour = date.getHours();
         const day = date.getDay();
         
         hourlyDistribution[hour] = (hourlyDistribution[hour] || 0) + 1;
         dailyDistribution[day] = (dailyDistribution[day] || 0) + 1;
       }
     });
     
     return {
       total: signatures.length,
       successful,
       failed,
       statusDistribution,
       timeDistribution: {
         hourly: hourlyDistribution,
         daily: dailyDistribution
       },
       metadata: {
         startTime: signatures[0]?.blockTime || 0,
         endTime: signatures[signatures.length - 1]?.blockTime || 0,
         duration: signatures.length > 1
           ? (signatures[0]?.blockTime || 0) - (signatures[signatures.length - 1]?.blockTime || 0)
           : 0
       }
     };
   }
   ```