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

> Retrieve inbound and outbound transfer history for a wallet

<Warning>
  **You are viewing docs for the previous version of the Wallets SDK.** We recommend upgrading to V1.
  See the [updated version of this page](/wallets/guides/list-transfers) or the [V1 migration guide](/wallets/guides/migrate-to-v1).
</Warning>

<Warning>
  This is an **unstable API** that may change with time. The `unstable` prefix indicates that breaking changes may occur in future releases.
</Warning>

## Overview

The List Wallet Transfers API allows you to retrieve the transfer history for a wallet, including both inbound and outbound token transfers. This endpoint supports multiple blockchains and provides cursor-based pagination for efficient data retrieval.

## Prerequisites

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

## Retrieving Wallet Transfers

<Tabs>
  <Tab title="EVM Chains">
    ### Get Ethereum Sepolia USDC Transfers

    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
        --url 'https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:evm-smart-wallet/transfers?chain=ethereum-sepolia&tokens=usdc&status=successful&limit=10' \
        --header 'X-API-KEY: <your-server-api-key>'
      ```

      ```javascript Node.js theme={null}
      const url = "https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:evm-smart-wallet/transfers";
      const params = new URLSearchParams({
          chain: "ethereum-sepolia",
          tokens: "usdc",
          status: "successful",
          limit: "10"
      });

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

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

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

      url = "https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:evm-smart-wallet/transfers"
      params = {
          "chain": "ethereum-sepolia",
          "tokens": "usdc",
          "status": "successful",
          "limit": "10"
      }
      headers = {"X-API-KEY": "<your-server-api-key>"}

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

    ### Paginating Through Results

    When your wallet has a lot of transactions, results are split into pages. Use the `nextCursor` value from each response in your next API call to get the next page of results.

    <CodeGroup>
      ```javascript Node.js theme={null}
      async function getAllTransfers(walletLocator, chain, tokens) {
          const baseUrl = `https://staging.crossmint.com/api/unstable/wallets/${walletLocator}/transfers`;
          const allTransfers = [];
          let cursor = null;

          do {
              const params = new URLSearchParams({
                  chain,
                  tokens,
                  status: "successful",
                  limit: "30"
              });

              if (cursor) {
                  params.set("cursor", cursor);
              }

              const response = await fetch(`${baseUrl}?${params}`, {
                  headers: { "X-API-KEY": "<your-server-api-key>" }
              });

              const result = await response.json();
              allTransfers.push(...result.data);
              cursor = result.nextCursor;
          } while (cursor);

          return allTransfers;
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Solana">
    ### Get Solana USDC Transfers

    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
        --url 'https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:solana:smart/transfers?chain=solana&tokens=usdc&status=successful&limit=10' \
        --header 'X-API-KEY: <your-server-api-key>'
      ```

      ```javascript Node.js theme={null}
      const url = "https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:solana:smart/transfers";
      const params = new URLSearchParams({
          chain: "solana",
          tokens: "usdc",
          status: "successful",
          limit: "10"
      });

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

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

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

      url = "https://staging.crossmint.com/api/unstable/wallets/email:user@example.com:solana:smart/transfers"
      params = {
          "chain": "solana",
          "tokens": "usdc",
          "status": "successful",
          "limit": "10"
      }
      headers = {"X-API-KEY": "<your-server-api-key>"}

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

    ### Paginating Through Results

    When your wallet has a lot of transactions, results are split into pages. Use the `nextCursor` value from each response in your next API call to get the next page of results.

    <CodeGroup>
      ```javascript Node.js theme={null}
      async function getAllTransfers(walletLocator, chain, tokens) {
          const baseUrl = `https://staging.crossmint.com/api/unstable/wallets/${walletLocator}/transfers`;
          const allTransfers = [];
          let cursor = null;

          do {
              const params = new URLSearchParams({
                  chain,
                  tokens,
                  status: "successful",
                  limit: "30"
              });

              if (cursor) {
                  params.set("cursor", cursor);
              }

              const response = await fetch(`${baseUrl}?${params}`, {
                  headers: { "X-API-KEY": "<your-server-api-key>" }
              });

              const result = await response.json();
              allTransfers.push(...result.data);
              cursor = result.nextCursor;
          } while (cursor);

          return allTransfers;
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Stellar">
    ### Get Stellar USDC Transfers

    <CodeGroup>
      ```bash cURL theme={null}
      curl --request GET \
        --url 'https://staging.crossmint.com/api/unstable/wallets/GABCD1234.../transfers?chain=stellar&tokens=usdc&status=successful' \
        --header 'X-API-KEY: <your-server-api-key>'
      ```

      ```javascript Node.js theme={null}
      const url = "https://staging.crossmint.com/api/unstable/wallets/GABCD1234.../transfers";
      const params = new URLSearchParams({
          chain: "stellar",
          tokens: "usdc",
          status: "successful"
      });

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

      const data = await response.json();
      console.log(data);
      ```
    </CodeGroup>

    ### Paginating Through Results

    When your wallet has a lot of transactions, results are split into pages. Use the `nextCursor` value from each response in your next API call to get the next page of results.

    <CodeGroup>
      ```javascript Node.js theme={null}
      async function getAllTransfers(walletLocator, chain, tokens) {
          const baseUrl = `https://staging.crossmint.com/api/unstable/wallets/${walletLocator}/transfers`;
          const allTransfers = [];
          let cursor = null;

          do {
              const params = new URLSearchParams({
                  chain,
                  tokens,
                  status: "successful",
                  limit: "30"
              });

              if (cursor) {
                  params.set("cursor", cursor);
              }

              const response = await fetch(`${baseUrl}?${params}`, {
                  headers: { "X-API-KEY": "<your-server-api-key>" }
              });

              const result = await response.json();
              allTransfers.push(...result.data);
              cursor = result.nextCursor;
          } while (cursor);

          return allTransfers;
      }
      ```
    </CodeGroup>
  </Tab>
</Tabs>

## API Reference

Two endpoints are available:

* `GET /unstable/wallets/{walletLocator}/transfers` — Server-side API key authentication
* `GET /unstable/wallets/me:walletLocator/transfers` — JWT authentication for the current user's wallet

See the [API reference](/api-reference/wallets/list-transfers) for full parameter details and to test requests in the playground.

## Important Notes

<AccordionGroup>
  <Accordion title="Chain Support">
    * **EVM chains**: Fully supported. Results are cached for 10 minutes to improve performance.
    * **Solana**: Supported. Includes native SOL and SPL token transfers (e.g., USDC). Results are cached for 10 minutes.
    * **Stellar**: Supported with tokens `usdc`, `usdm0`, `usdm1`, and `usdxm`.
  </Accordion>

  <Accordion title="EVM Limitations">
    Outgoing smart wallet native token transfers (e.g., ETH, MATIC) are not supported on all EVM chains. This limitation affects chains where internal transaction tracing is not available.
  </Accordion>

  <Accordion title="Pagination">
    * Uses cursor-based pagination for efficient data retrieval
    * Supports bidirectional pagination with `nextCursor` and `previousCursor`
    * The cursor encodes the sort order, so you don't need to re-specify it when paginating
    * Activity sessions expire after 10 minutes on EVM and Solana chains; refresh to load the latest data if the cursor expires
  </Accordion>

  <Accordion title="Timestamps">
    All timestamps are returned in ISO 8601 format (e.g., `2025-01-15T10:30:00.000Z`).
  </Accordion>

  <Accordion title="Transfer Types">
    The API returns both inbound (`wallets.transfer.in`) and outbound (`wallets.transfer.out`) transfers. Transfers initiated through Crossmint include a `transferId` that can be used with the [Get Transaction API](/api-reference/wallets/get-transaction).
  </Accordion>
</AccordionGroup>