createKrakenExchangeTransfer

Creates a transfer from a Kraken exchange account to an external wallet address. This allows users to withdraw cryptocurrency from their Kraken holdings to a wallet they control. Before calling this function, use getKrakenAccounts to get the accountId and verify available balance, and getKrakenWhitelistedAddresses to check if the destination address is valid.

Usage

import {
  createKrakenExchangeTransfer,
  getKrakenAccounts,
} from '@dynamic-labs-sdk/client';

// Get the user's Kraken accounts
const accounts = await getKrakenAccounts();

// Create a transfer from the first account
const transfer = await createKrakenExchangeTransfer({
  accountId: accounts[0].id,
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f7ABCD',
  amount: 0.5,
  currency: 'ETH',
});

console.log('Transfer ID:', transfer.id);
console.log('Status:', transfer.status);

Parameters

Parameter	Type	Description
`accountId`	`string`	The Kraken account ID to transfer from. Get this from `getKrakenAccounts()`.
`to`	`string`	The destination wallet address. Must be whitelisted if the user has address whitelisting enabled.
`amount`	`number`	The amount to transfer.
`currency`	`string`	The cryptocurrency to transfer (e.g., `'ETH'`, `'BTC'`, `'USDC'`).
`description`	`string` (optional)	A description for the transfer.
`network`	`string` (optional)	Network name (e.g., `'ethereum'`, `'polygon'`).
`networkObject`	`object` (optional)	Network details with `chainName` and `networkId`. Use this for multi-network tokens.
`networkObject.chainName`	`string`	The chain name (e.g., `'EVM'`).
`networkObject.networkId`	`string`	The network ID (e.g., `'1'` for Ethereum mainnet, `'137'` for Polygon).
`mfaCode`	`string` (optional)	MFA code if required by the user’s Kraken account settings.
`id`	`string` (optional)	Idempotency key to prevent duplicate transfers on retry.
`client`	`DynamicClient` (optional)	The Dynamic client instance. Only required when using multiple clients.

Returns

Promise<ExchangeTransferResponse> - A promise that resolves to the transfer details:

type ExchangeTransferResponse = {
  id: string;                  // Unique transfer ID
  exchangeAccountId?: string;  // The Kraken account ID
  status?: string;             // Transfer status: 'pending', 'completed', 'failed', etc.
  amount: number;              // Amount transferred
  currency: string;            // Currency code
  createdAt?: Date;            // When the transfer was created
};

Transfer Status Values

Status	Description
`pending`	Transfer has been submitted and is being processed
`completed`	Transfer has been successfully completed
`failed`	Transfer failed (check error details)

Examples

Basic transfer

import {
  createKrakenExchangeTransfer,
  getKrakenAccounts,
} from '@dynamic-labs-sdk/client';

const transferEth = async (destinationAddress, amount) => {
  // Get accounts and find one with ETH balance
  const accounts = await getKrakenAccounts();

  const accountWithEth = accounts.find(acc =>
    acc.balances.some(b => b.currency === 'ETH' && b.balance >= amount)
  );

  if (!accountWithEth) {
    throw new Error('No account with sufficient ETH balance');
  }

  const transfer = await createKrakenExchangeTransfer({
    accountId: accountWithEth.id,
    to: destinationAddress,
    amount,
    currency: 'ETH',
    description: 'Withdraw ETH to wallet',
  });

  return transfer;
};

// Usage
const transfer = await transferEth('0x742d35Cc...', 0.1);
console.log('Transfer created:', transfer.id);

Transfer USDC on a specific network

When transferring tokens that exist on multiple networks, specify the target network:

import { ChainEnum } from '@dynamic-labs/sdk-api-core';
import { createKrakenExchangeTransfer } from '@dynamic-labs-sdk/client';

// Transfer USDC to Polygon
const transfer = await createKrakenExchangeTransfer({
  accountId: 'acc_123',
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f7ABCD',
  amount: 100,
  currency: 'USDC',
  networkObject: {
    chainName: ChainEnum.Evm,
    networkId: '137', // Polygon
  },
  description: 'USDC to Polygon wallet',
});

// Transfer USDC to Ethereum mainnet
const mainnetTransfer = await createKrakenExchangeTransfer({
  accountId: 'acc_123',
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f7ABCD',
  amount: 100,
  currency: 'USDC',
  networkObject: {
    chainName: ChainEnum.Evm,
    networkId: '1', // Ethereum mainnet
  },
});

Transfer with MFA

If the user has MFA enabled on their Kraken account:

import { createKrakenExchangeTransfer } from '@dynamic-labs-sdk/client';

const transferWithMfa = async (params, mfaCode) => {
  const transfer = await createKrakenExchangeTransfer({
    ...params,
    mfaCode, // User-provided MFA code from their authenticator app
  });

  return transfer;
};

// Usage with user-provided MFA code
const transfer = await transferWithMfa(
  {
    accountId: 'acc_123',
    to: '0x742d35...',
    amount: 1.0,
    currency: 'BTC',
  },
  '123456' // MFA code from user
);

Idempotent transfers

Use an idempotency key to safely retry failed requests without creating duplicate transfers:

import { createKrakenExchangeTransfer } from '@dynamic-labs-sdk/client';
import { v4 as uuidv4 } from 'uuid';

const createSafeTransfer = async (params) => {
  // Generate a unique ID for this transfer request
  const transferId = uuidv4();

  const transfer = await createKrakenExchangeTransfer({
    ...params,
    id: transferId, // Idempotency key
  });

  return transfer;
};

// If the network fails and you retry, the same transfer is returned
// instead of creating a duplicate

Complete transfer flow with validation

import {
  getKrakenAccounts,
  getKrakenWhitelistedAddresses,
  createKrakenExchangeTransfer,
} from '@dynamic-labs-sdk/client';

const findFundedAccount = ({ accounts, currency, amount }) => {
  for (const account of accounts) {
    const balance = account.balances.find(b => b.currency === currency);
    if (!balance) continue;

    // availableBalance is optional; fall back to the total balance.
    const available = balance.availableBalance || balance.balance;
    if (available >= amount) return account;
  }

  return undefined;
};

const executeTransfer = async ({ currency, amount, destinationAddress }) => {
  // Step 1: Get accounts and verify balance
  const accounts = await getKrakenAccounts();
  const fundedAccount = findFundedAccount({ accounts, amount, currency });

  if (!fundedAccount) {
    throw new Error(
      `Insufficient ${currency} balance. Requested: ${amount}`
    );
  }

  // Step 2: Verify destination address is whitelisted (if required)
  const { destinations, enforcesAddressWhitelist } =
    await getKrakenWhitelistedAddresses();

  if (enforcesAddressWhitelist) {
    const isWhitelisted = destinations.some(
      dest =>
        dest.address.toLowerCase() === destinationAddress.toLowerCase() &&
        dest.tokens?.includes(currency)
    );

    if (!isWhitelisted) {
      throw new Error(
        `Address ${destinationAddress} is not whitelisted for ${currency}. ` +
        'Add it in your Kraken account settings.'
      );
    }
  }

  // Step 3: Create the transfer
  const transfer = await createKrakenExchangeTransfer({
    accountId: fundedAccount.id,
    to: destinationAddress,
    amount,
    currency,
  });

  return {
    success: true,
    transferId: transfer.id,
    status: transfer.status,
    amount: transfer.amount,
    currency: transfer.currency,
  };
};

// Usage
try {
  const result = await executeTransfer({
    currency: 'ETH',
    amount: 0.5,
    destinationAddress: '0x742d35Cc6634C0532925a3b844Bc9e7595f7ABCD',
  });
  console.log('Transfer successful:', result);
} catch (error) {
  console.error('Transfer failed:', error.message);
}

React

import { useCreateKrakenExchangeTransfer } from '@dynamic-labs-sdk/react-hooks';

const TransferButton = ({
  accountId,
  currency,
  destination,
  amount,
  onSuccess,
  onError,
}) => {
  const { mutate: createKrakenExchangeTransfer, isPending } = useCreateKrakenExchangeTransfer();

  const handleTransfer = () => {
    createKrakenExchangeTransfer(
      { accountId, to: destination, amount: parseFloat(amount), currency },
      {
        onSuccess: (transfer) => onSuccess(transfer),
        onError: (error) => onError(error.message),
      },
    );
  };

  return (
    <button onClick={handleTransfer} disabled={isPending}>
      {isPending ? 'Processing...' : `Transfer ${amount} ${currency}`}
    </button>
  );
};

Handle transfer errors

import { createKrakenExchangeTransfer } from '@dynamic-labs-sdk/client';

const handleTransfer = async (params) => {
  try {
    const transfer = await createKrakenExchangeTransfer(params);
    return { success: true, transfer };
  } catch (error) {
    const message = error.message || 'Unknown error';

    // Handle specific error cases
    if (message.includes('insufficient') || message.includes('balance')) {
      return {
        success: false,
        error: 'Insufficient balance for this transfer',
        code: 'INSUFFICIENT_BALANCE',
      };
    }

    if (message.includes('whitelist')) {
      return {
        success: false,
        error: 'Destination address is not whitelisted',
        code: 'NOT_WHITELISTED',
      };
    }

    if (message.includes('mfa') || message.includes('authentication')) {
      return {
        success: false,
        error: 'MFA verification required',
        code: 'MFA_REQUIRED',
      };
    }

    return {
      success: false,
      error: message,
      code: 'UNKNOWN_ERROR',
    };
  }
};

Prerequisites

User must have connected their Kraken account through Dynamic
The destination address must be whitelisted in Kraken if the user has address whitelisting enabled
The Kraken account must have sufficient balance for the transfer
Add account.fast-api-key:funds-query, account.fast-api-key:funds-withdraw, account.fast-api-key:ledger-query, and account.fast-api-key:write to the Kraken OAuth provider’s Additional Scopes field in the Dynamic Console. All Kraken functions require these scopes.

Notes

Transfers are processed by Kraken and may take time to complete depending on network conditions
The status field indicates the current state of the transfer
Use idempotency keys (id parameter) in production to prevent duplicate transfers from network retries
For tokens on multiple networks (like USDC), always specify the networkObject to ensure the transfer goes to the correct chain

getKrakenAccounts - Get user’s Kraken account balances
getKrakenWhitelistedAddresses - Get whitelisted withdrawal addresses
Kraken Integration Guide - Complete integration overview

​createKrakenExchangeTransfer

​Usage

​Parameters

​Returns

​Transfer Status Values

​Examples

​Basic transfer

​Transfer USDC on a specific network

​Transfer with MFA

​Idempotent transfers

​Complete transfer flow with validation

​React

​Handle transfer errors

​Prerequisites

​Notes

​Related