Skip to main content

​
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

ParameterTypeDescription
paramsGetKrakenAccountsParams (optional)Optional filters for the accounts.
params.chainNameChain (optional)Filter by blockchain (e.g., 'EVM', 'SOL', 'BTC').
params.networkIdnumber (optional)Filter by network ID (e.g., 1 for Ethereum mainnet).
clientDynamicClient (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