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

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:

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

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

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

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

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

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

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

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 - Transfer crypto from Kraken
• getKrakenWhitelistedAddresses - Get whitelisted withdrawal addresses
• Kraken Integration Guide - Complete integration overview