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

# getKrakenAccounts

# getKrakenAccounts

Retrieves the authenticated user's Kraken exchange accounts with their balances. Each account contains multiple currency balances representing the user's holdings on Kraken.

Use this function to display available funds and to get the `accountId` required for creating transfers.

## Usage

```javascript theme={"system"}
import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const accounts = await getKrakenAccounts();

accounts.forEach(account => {
  console.log(`Account: ${account.name || account.id}`);
  account.balances.forEach(balance => {
    console.log(`  ${balance.currency}: ${balance.balance}`);
  });
});
```

## Parameters

| Parameter          | Type                                 | Description                                                             |
| ------------------ | ------------------------------------ | ----------------------------------------------------------------------- |
| `params`           | `GetKrakenAccountsParams` (optional) | Optional filters for the accounts.                                      |
| `params.chainName` | `Chain` (optional)                   | Filter by blockchain (e.g., `'EVM'`, `'SOL'`, `'BTC'`).                 |
| `params.networkId` | `number` (optional)                  | Filter by network ID (e.g., `1` for Ethereum mainnet).                  |
| `client`           | `DynamicClient` (optional)           | The Dynamic client instance. Only required when using multiple clients. |

## Returns

`Promise<KrakenAccount[]>` - A promise that resolves to an array of Kraken accounts:

```typescript theme={"system"}
type KrakenAccount = {
  id: string;               // Unique account ID (use this for transfers)
  exchange: 'kraken';
  name?: string;            // User-assigned account name
  type?: string;            // Account type (e.g., 'spot')
  chain?: string;           // Blockchain network if relevant
  balances: Array<{
    currency: string;       // Currency code (e.g., 'ETH', 'BTC', 'USDC')
    balance: number;        // Total balance
    availableBalance?: number; // Balance available for withdrawal
    logoURI?: string;       // Token logo URL
  }>;
};
```

## Examples

### Get all accounts

```javascript theme={"system"}
import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const accounts = await getKrakenAccounts();

// Log all balances across all accounts
accounts.forEach(account => {
  console.log(`Account: ${account.name || account.type || account.id}`);
  account.balances.forEach(({ currency, balance, availableBalance }) => {
    console.log(`  ${currency}: ${balance}`);
    if (availableBalance && availableBalance !== balance) {
      console.log(`    Available: ${availableBalance}`);
    }
  });
});
```

### Filter by blockchain

```javascript theme={"system"}
import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

// Get only EVM-compatible assets (ETH, ERC-20 tokens, etc.)
const evmAccounts = await getKrakenAccounts({ chainName: 'EVM' });

// Get only Solana assets
const solanaAccounts = await getKrakenAccounts({ chainName: 'SOL' });

// Get only Bitcoin
const bitcoinAccounts = await getKrakenAccounts({ chainName: 'BTC' });
```

### Filter by network

```javascript theme={"system"}
import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

// Get assets on Ethereum mainnet only
const mainnetAccounts = await getKrakenAccounts({
  chainName: 'EVM',
  networkId: 1,
});

// Get assets on Polygon
const polygonAccounts = await getKrakenAccounts({
  chainName: 'EVM',
  networkId: 137,
});
```

### Find a specific currency balance

```javascript theme={"system"}
import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const findBalance = async (currency) => {
  const accounts = await getKrakenAccounts();

  for (const account of accounts) {
    const balance = account.balances.find(b => b.currency === currency);
    if (balance) {
      return {
        accountId: account.id,
        currency: balance.currency,
        balance: balance.balance,
        available: balance.availableBalance ?? balance.balance,
      };
    }
  }

  return null;
};

// Usage
const ethBalance = await findBalance('ETH');
if (ethBalance) {
  console.log(`ETH Balance: ${ethBalance.balance}`);
  console.log(`Account ID: ${ethBalance.accountId}`);
}
```

### Check if user has sufficient balance

```javascript theme={"system"}
import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const hasSufficientBalance = async (currency, requiredAmount) => {
  const accounts = await getKrakenAccounts();

  for (const account of accounts) {
    const balance = account.balances.find(b => b.currency === currency);
    if (balance) {
      const available = balance.availableBalance ?? balance.balance;
      if (available >= requiredAmount) {
        return { hasBalance: true, accountId: account.id, available };
      }
    }
  }

  return { hasBalance: false, accountId: null, available: 0 };
};

// Usage
const { hasBalance, accountId, available } = await hasSufficientBalance('ETH', 0.5);

if (!hasBalance) {
  console.log(`Insufficient ETH. You have ${available} ETH available.`);
} else {
  console.log(`Ready to transfer from account ${accountId}`);
}
```

### Display balances in React

```javascript theme={"system"}
import { useState, useEffect } from 'react';
import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const KrakenBalances = () => {
  const [accounts, setAccounts] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    const fetchBalances = async () => {
      try {
        const data = await getKrakenAccounts();
        setAccounts(data);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    };

    fetchBalances();
  }, []);

  if (loading) return <div>Loading balances...</div>;
  if (error) return <div>Error: {error}</div>;
  if (accounts.length === 0) return <div>No Kraken accounts found</div>;

  return (
    <div>
      <h3>Your Kraken Balances</h3>
      {accounts.map(account => (
        <div key={account.id}>
          <h4>{account.name || `Account ${account.id.slice(0, 8)}`}</h4>
          <ul>
            {account.balances
              .filter(b => b.balance > 0)
              .map(balance => (
                <li key={balance.currency}>
                  <strong>{balance.currency}:</strong> {balance.balance}
                </li>
              ))}
          </ul>
        </div>
      ))}
    </div>
  );
};
```

### Get total value across all accounts

```javascript theme={"system"}
import { getKrakenAccounts } from '@dynamic-labs-sdk/client';

const getTotalBalanceForCurrency = async (currency) => {
  const accounts = await getKrakenAccounts();

  let total = 0;
  const accountBreakdown = [];

  for (const account of accounts) {
    const balance = account.balances.find(b => b.currency === currency);
    if (balance) {
      total += balance.balance;
      accountBreakdown.push({
        accountId: account.id,
        accountName: account.name,
        balance: balance.balance,
      });
    }
  }

  return { total, accounts: accountBreakdown };
};

// Usage
const ethTotal = await getTotalBalanceForCurrency('ETH');
console.log(`Total ETH: ${ethTotal.total}`);
ethTotal.accounts.forEach(acc => {
  console.log(`  ${acc.accountName || acc.accountId}: ${acc.balance} ETH`);
});
```

## Prerequisites

* User must have connected their Kraken account through Dynamic
* User must be authenticated

## Related

* [`createKrakenExchangeTransfer`](/javascript/reference/client/create-kraken-exchange-transfer) - Transfer crypto from Kraken
* [`getKrakenWhitelistedAddresses`](/javascript/reference/client/get-kraken-whitelisted-addresses) - Get whitelisted withdrawal addresses
* [Kraken Integration Guide](/javascript/reference/client/kraken-integration) - Complete integration overview