---
title: getSignaturesForAddress
description: >-
  Returns confirmed transaction signatures for transactions that reference the
  supplied address in accountKeys, newest first.
url: /docs/rpc/http/getsignaturesforaddress
type: reference
hideTableOfContents: true
---

Returns confirmed transaction signatures for transactions that reference the
supplied address in `accountKeys`, newest first.

<Callout type="info" title="Source">
  [`get_signatures_for_address`](https://github.com/anza-xyz/agave/blob/v3.1.8/rpc/src/rpc.rs#L1816)
</Callout>

<APIMethod>

```jsonc !!request curl
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getSignaturesForAddress",
  "params": [
    // !hover address
    "Vote111111111111111111111111111111111111111",
    // !hover(1:4) config
    {
      // !hover commitment
      "commitment": "finalized",
      // !hover limit
      "limit": 1
    }
  ]
}
```

```ts !!request title="Kit"
import { address, createSolanaRpc } from "@solana/kit";

const rpc_url = "https://api.devnet.solana.com";
const rpc = createSolanaRpc(rpc_url);

// !hover address
let addr = address("Vote111111111111111111111111111111111111111");

// !hover(1:3) config
let signaturesForConfig = {
  // !hover limit
  limit: 1
};

let signatures = await rpc
  .getSignaturesForAddress(addr, signaturesForConfig)
  .send();

console.log(signatures);
```

```ts !!request title="web3.js"
import {
  Connection,
  PublicKey,
  clusterApiUrl,
  type SignaturesForAddressOptions
} from "@solana/web3.js";

const connection = new Connection(clusterApiUrl("devnet"), "confirmed");

// !hover(1:3) config
let signaturesOptions: SignaturesForAddressOptions = {
  // !hover limit
  limit: 1
};

// !hover address
let address = new PublicKey("Vote111111111111111111111111111111111111111");
let signatures = await connection.getSignaturesForAddress(
  address,
  signaturesOptions
);

console.log(signatures);
```

```rs !!request title="Rust"
use anyhow::Result;
use solana_client::{
    nonblocking::rpc_client::RpcClient, rpc_client::GetConfirmedSignaturesForAddress2Config,
};
use solana_commitment_config::CommitmentConfig;
use solana_sdk::pubkey;

#[tokio::main]
async fn main() -> Result<()> {
    let client = RpcClient::new_with_commitment(
        String::from("https://api.devnet.solana.com"),
        CommitmentConfig::confirmed(),
    );

    // !hover address
    let address = pubkey!("Vote111111111111111111111111111111111111111");

    // !hover(1:6) config
    let signatures_for_config = GetConfirmedSignaturesForAddress2Config {
        // !hover before
        before: None,
        // !hover until
        until: None,
        // !hover limit
        limit: Some(1),
        // !hover commitment
        commitment: CommitmentConfig::finalized().into(),
    };

    let signatures = client
        .get_signatures_for_address_with_config(&address, signatures_for_config)
        .await?;

    println!("{:#?}", signatures);

    Ok(())
}
```

### !params

#### !! address

!type string  
!required

Account address as base-58 encoded string

#### !! config

!type object

Configuration object containing the following fields:

##### !! commitment

!type string  
!values confirmed finalized  
!default finalized

Solana RPC uses the following commitment levels:

| Value       | Description                                                                                                                                                                                                                                                                |
| ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `processed` | Return data from the highest slot this node has processed on the fork it currently considers best. This is the newest view, but it can still change if the cluster switches forks.                                                                                         |
| `confirmed` | Return data from the highest slot that at least two-thirds of active stake has directly voted to confirm. This is more stable than `processed`, but it is still a weaker guarantee than `finalized`.                                                                       |
| `finalized` | Return data from the highest slot that the cluster recognizes as finalized. In practice, this means the slot has reached maximum vote lockout in validators' vote towers and is recognized by at least two-thirds of active stake. This is the strongest commitment level. |

This method does not accept `processed`.

##### !! minContextSlot

!type number

The minimum slot that the request can be evaluated at

```json title="Example"
{ "minContextSlot": 341197000 }
```

##### !! limit

!type usize  
!default 1000

Maximum transaction signatures to return (between 1 and 1,000).

##### !! before

!type string

Start searching backwards from this transaction signature. If not provided the
search starts from the top of the highest max confirmed block.

```json title="Example"
{
  "before": "5h6xBEauJ3PK6SWCz5Qq8DbD4t7VDdaRhfvsRrHBhXX2x4dLZxN1YhJpN96CBvs1BgqsSVqSogn8CA9nVddrzNRs"
}
```

##### !! until

!type string

Search until this transaction signature, if found before limit reached

```json title="Example"
{
  "until": "2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR6ykBvDxrTQrtpb"
}
```

### !!result

```jsonc !response
{
  "jsonrpc": "2.0",
  // !hover(1:10) result
  "result": [
    {
      // !hover signature
      "signature": "5h6xBEauJ3PK6SWCZ1PGjBvj8vDdWG3KpwATGy1ARAXFSDwt8GFXM7W5Ncn16wmqokgpiKRLuS83KUxyZyv2sUYv",
      // !hover slot
      "slot": 114,
      // !hover err
      "err": null,
      // !hover memo
      "memo": null,
      // !hover blockTime
      "blockTime": null,
      // !hover confirmationStatus
      "confirmationStatus": "finalized"
    }
  ],
  "id": 1
}
```

!type array

An array of transaction signature information objects, ordered from **newest**
to **oldest** transaction, containing:

##### !! signature

!type string

Transaction signature as base-58 encoded string

##### !! slot

!type u64

The slot that contains the block with the transaction

##### !! err

!type object | string | null

Error if the transaction failed. `null` if the transaction succeeded.

When `err` is returned as an object, it is a transaction error enum payload
rather than a fixed JSON schema:

| Field           | Type                                | Description                                                                                                                                     |
| --------------- | ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `<variantName>` | `array \| object \| string \| null` | Transaction error variant payload. Most variants serialize as strings. `InstructionError` serializes as `[instructionIndex, instructionError]`. |

##### !! memo

!type string | null

Memo associated with the transaction, null if no memo is present

##### !! blockTime

!type i64 | null

Estimated production time, as Unix timestamp (seconds since the Unix epoch) of
when transaction was processed. null if not available.

##### !! confirmationStatus

!type string | null

The transaction's cluster confirmation status; Either `processed`, `confirmed`,
or `finalized`. See [Commitment](/docs/rpc/#configuring-state-commitment) for
more on optimistic confirmation.

</APIMethod>