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

# List Wallet Signers

> Retrieve all operational signers registered on a wallet, check registration status, and access the recovery signer

<Note>
  **This page has been updated for Wallets SDK V1.** If you are using the previous version,
  see the [previous version docs](/wallets/v0/overview) or the [V1 migration guide](/wallets/guides/migrate-to-v1).
</Note>

## Overview

The List Wallet Signers API allows you to retrieve all operational signers registered on a wallet. Each signer includes its type, locator, and current status. The recovery signer is accessed separately via `wallet.recovery`. This is useful for displaying signer management UIs, checking which signers are active, or verifying that a new signer was registered successfully.

## Prerequisites

* You have a wallet created
* **API Key**: You have an API key with the scope: `wallets.read`. In staging, all scopes are included

## Listing Signers

<Tabs>
  <Tab title="React">
    ```typescript theme={null}
    import { useWallet } from "@crossmint/client-sdk-react-ui";

    const { wallet } = useWallet();

    const signers = await wallet.signers();

    for (const signer of signers) {
        console.log(signer.type, signer.locator, signer.status);
    }
    ```
  </Tab>

  <Tab title="Flutter">
    ```dart theme={null}
    import 'package:crossmint_flutter/crossmint_flutter_ui.dart';

    final controller = CrossmintWalletContext.of(context).requireWalletController;
    final wallet = controller.createEvmWallet();

    final signers = await wallet.signers();
    for (final signer in signers) {
      print('${signer.type} ${signer.locator} ${signer.status}');
    }

    // Check a specific signer
    final isRegistered = await wallet.signerIsRegistered('device:abc123');

    // Recovery is available on the runtime wallet:
    final recovery = wallet.recovery;
    ```
  </Tab>

  <Tab title="Node.js">
    ### With a Wallet Address

    ```typescript theme={null}
    import {
        createCrossmint,
        CrossmintWallets,
    } from "@crossmint/wallets-sdk";

    const crossmint = createCrossmint({
        apiKey: "<your-server-api-key>",
    });
    const wallets = CrossmintWallets.from(crossmint);

    const wallet = await wallets.getWallet(
        "YOUR_WALLET_ADDRESS",
        { chain: "base-sepolia" }
    );

    const signers = await wallet.signers();

    for (const signer of signers) {
        console.log(signer.type, signer.locator, signer.status);
    }
    ```

    ### With a User Locator

    ```typescript theme={null}
    const wallet = await wallets.getWallet(
        "email:user@example.com",
        { chain: "base-sepolia" }
    );

    const signers = await wallet.signers();
    console.log(signers);
    ```
  </Tab>

  <Tab title="REST">
    Fetch the wallet details — signers are included in the response under the `config` field.

    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
          --url 'https://staging.crossmint.com/api/2025-06-09/wallets/<WALLET_ADDRESS>' \
          --header 'X-API-KEY: <your-server-api-key>'
      ```

      ```javascript Node.js theme={null}
      const url =
          "https://staging.crossmint.com/api/2025-06-09/wallets/<WALLET_ADDRESS>";

      const response = await fetch(url, {
          method: "GET",
          headers: {
              "X-API-KEY": "<your-server-api-key>",
          },
      });

      const data = await response.json();

      // Recovery signer
      console.log("Recovery:", data.config?.adminSigner);

      // Operational signers
      console.log("Signers:", data.config?.delegatedSigners);
      ```

      ```python Python theme={null}
      import requests

      url = "https://staging.crossmint.com/api/2025-06-09/wallets/<WALLET_ADDRESS>"
      headers = {"X-API-KEY": "<your-server-api-key>"}

      response = requests.get(url, headers=headers)
      data = response.json()

      # Recovery signer
      print("Recovery:", data.get("config", {}).get("adminSigner"))

      # Operational signers
      print("Signers:", data.get("config", {}).get("delegatedSigners"))
      ```
    </CodeGroup>

    You can also retrieve a specific signer by its locator:

    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
          --url 'https://staging.crossmint.com/api/2025-06-09/wallets/<WALLET_ADDRESS>/signers/<SIGNER_LOCATOR>' \
          --header 'X-API-KEY: <your-server-api-key>'
      ```

      ```javascript Node.js theme={null}
      const url =
          "https://staging.crossmint.com/api/2025-06-09/wallets/<WALLET_ADDRESS>/signers/<SIGNER_LOCATOR>";

      const response = await fetch(url, {
          method: "GET",
          headers: {
              "X-API-KEY": "<your-server-api-key>",
          },
      });

      const signer = await response.json();
      console.log(signer);
      ```

      ```python Python theme={null}
      import requests

      url = "https://staging.crossmint.com/api/2025-06-09/wallets/<WALLET_ADDRESS>/signers/<SIGNER_LOCATOR>"
      headers = {"X-API-KEY": "<your-server-api-key>"}

      response = requests.get(url, headers=headers)
      print(response.json())
      ```
    </CodeGroup>

    See the [Get Signer API reference](/api-reference/wallets/get-signer) for full parameter details and to test requests in the playground.
  </Tab>
</Tabs>

## Checking If a Signer Is Registered

Use `signerIsRegistered()` to check whether a specific signer is already registered on the wallet, without retrieving the full list:

```typescript theme={null}
const isRegistered = await wallet.signerIsRegistered("device:abc123");
console.log("Registered:", isRegistered); // true or false
```

## Accessing the Recovery Signer

The recovery signer is separate from the operational signers returned by `wallet.signers()`. Access it directly:

```typescript theme={null}
const recovery = wallet.recovery;
console.log("Recovery type:", recovery.type);
```

## Signer Response Shape

Each operational signer returned by `wallet.signers()` includes:

| Field     | Type           | Description                                                                     |
| --------- | -------------- | ------------------------------------------------------------------------------- |
| `type`    | `string`       | The signer type — `"device"`, `"passkey"`, `"external-wallet"`, or `"server"`   |
| `locator` | `string`       | Unique identifier for the signer (e.g., `"device:abc123"`, `"passkey:xyz789"`)  |
| `status`  | `SignerStatus` | Current status — `"success"`, `"pending"`, `"awaiting-approval"`, or `"failed"` |

## Important Notes

<AccordionGroup>
  <Accordion title="EVM Chain Filtering">
    For EVM wallets, `wallet.signers()` only returns signers that have an approval (pending or completed) for the wallet's specific chain. Signers registered on other chains are not included.
  </Accordion>

  <Accordion title="SDK vs REST API Field Names">
    The SDK uses `recovery` and `signers` terminology. When using the REST API directly, the corresponding fields are `adminSigner` (recovery) and `delegatedSigners` (operational signers).
  </Accordion>

  <Accordion title="Read-Only Wallet from getWallet (Server-Side)">
    When you retrieve a wallet server-side with `getWallet`, the wallet is in a read-only state — `wallet.signer` will be `undefined`. You must call `useSigner()` before performing any signing operations. However, `wallet.signers()` works without an active signer since it is a read operation.
  </Accordion>

  <Accordion title="Signer Status Values">
    * **`success`** — Signer is fully registered and active
    * **`pending`** — Registration is in progress
    * **`awaiting-approval`** — Signer needs approval from the recovery signer
    * **`failed`** — Registration failed
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup cols={3}>
  <Card title="Add Signers" icon="user-plus" href="/wallets/guides/signers/add-signers">
    Register additional signers on your wallet
  </Card>

  <Card title="Configure Recovery" icon="shield-halved" href="/wallets/guides/signers/configure-recovery">
    Set up recovery signers for your wallets
  </Card>

  <Card title="Transfer Tokens" icon="arrow-right-arrow-left" href="/wallets/guides/transfer-tokens">
    Send tokens from your wallet
  </Card>
</CardGroup>