Trading operations provide comprehensive functionality for executing trades, managing orders, and handling account operations on cryptocurrency exchanges. All trading operations require proper API credentials and permissions.
Fetch account balance information across all currencies.
/**
* Fetch account balances for all currencies
*/
fetchBalance(params?: object): Promise<Balances>;
interface Balances {
info: any;
[currency: string]: Balance | any;
free?: Dictionary<number>;
used?: Dictionary<number>;
total?: Dictionary<number>;
}
interface Balance {
/** Available balance for trading */
free: number;
/** Balance currently in use (in open orders) */
used: number;
/** Total balance (free + used) */
total: number;
}Usage Examples:
const exchange = new ccxt.binance({
apiKey: 'your-api-key',
secret: 'your-secret',
});
// Fetch all balances
const balance = await exchange.fetchBalance();
console.log('BTC Balance:', balance.BTC);
console.log('Free BTC:', balance.BTC.free);
console.log('Used BTC:', balance.BTC.used);
console.log('Total BTC:', balance.BTC.total);
// Iterate through all currencies
Object.entries(balance).forEach(([currency, bal]) => {
if (typeof balance === 'object' && bal.total > 0) {
console.log(`${currency}: Free ${bal.free}, Used ${bal.used}, Total ${bal.total}`);
}
});Create various types of trading orders.
/**
* Create a trading order
*/
createOrder(
symbol: string,
type: OrderType,
side: OrderSide,
amount: number,
price?: number,
params?: object
): Promise<Order>;
/**
* Create a market buy order
*/
createMarketBuyOrder(symbol: string, amount: number, params?: object): Promise<Order>;
/**
* Create a market sell order
*/
createMarketSellOrder(symbol: string, amount: number, params?: object): Promise<Order>;
/**
* Create a limit buy order
*/
createLimitBuyOrder(symbol: string, amount: number, price: number, params?: object): Promise<Order>;
/**
* Create a limit sell order
*/
createLimitSellOrder(symbol: string, amount: number, price: number, params?: object): Promise<Order>;
/**
* Create multiple orders at once
*/
createOrders(orders: OrderRequest[], params?: object): Promise<Order[]>;
interface OrderRequest {
symbol: string;
type: OrderType;
side: OrderSide;
amount: number;
price?: number;
params?: object;
}
type OrderType = 'market' | 'limit' | 'stop' | 'stop_limit' | string;
type OrderSide = 'buy' | 'sell';Usage Examples:
const exchange = new ccxt.binance({
apiKey: 'your-api-key',
secret: 'your-secret',
sandbox: true, // use testnet
});
await exchange.loadMarkets();
// Market buy order
const marketOrder = await exchange.createMarketBuyOrder('BTC/USDT', 0.001);
console.log('Market order created:', marketOrder.id);
// Limit sell order
const limitOrder = await exchange.createLimitSellOrder('BTC/USDT', 0.001, 50000);
console.log('Limit order created:', limitOrder.id);
// Generic order creation
const order = await exchange.createOrder('BTC/USDT', 'limit', 'buy', 0.001, 45000);
// Multiple orders
const orders = await exchange.createOrders([
{ symbol: 'BTC/USDT', type: 'limit', side: 'buy', amount: 0.001, price: 45000 },
{ symbol: 'ETH/USDT', type: 'limit', side: 'buy', amount: 0.1, price: 3000 },
]);Manage existing orders with cancel, edit, and query operations.
/**
* Cancel an order
*/
cancelOrder(id: string, symbol?: string, params?: object): Promise<Order>;
/**
* Cancel multiple orders
*/
cancelOrders(ids: string[], symbol?: string, params?: object): Promise<Order[]>;
/**
* Cancel all orders for a symbol
*/
cancelAllOrders(symbol?: string, params?: object): Promise<Order[]>;
/**
* Edit/modify an existing order
*/
editOrder(
id: string,
symbol: string,
type: OrderType,
side: OrderSide,
amount?: number,
price?: number,
params?: object
): Promise<Order>;Usage Examples:
const exchange = new ccxt.binance({
apiKey: 'your-api-key',
secret: 'your-secret',
});
// Cancel single order
const canceledOrder = await exchange.cancelOrder('12345', 'BTC/USDT');
console.log('Order canceled:', canceledOrder.status);
// Cancel multiple orders
const canceledOrders = await exchange.cancelOrders(['12345', '12346'], 'BTC/USDT');
// Cancel all orders for symbol
const allCanceled = await exchange.cancelAllOrders('BTC/USDT');
console.log(`Canceled ${allCanceled.length} orders`);
// Edit order (if supported)
const editedOrder = await exchange.editOrder(
'12345',
'BTC/USDT',
'limit',
'buy',
0.002, // new amount
46000 // new price
);Query order status and history.
/**
* Fetch a specific order by ID
*/
fetchOrder(id: string, symbol?: string, params?: object): Promise<Order>;
/**
* Fetch all orders (open and closed)
*/
fetchOrders(symbol?: string, since?: number, limit?: number, params?: object): Promise<Order[]>;
/**
* Fetch open orders only
*/
fetchOpenOrders(symbol?: string, since?: number, limit?: number, params?: object): Promise<Order[]>;
/**
* Fetch closed orders only
*/
fetchClosedOrders(symbol?: string, since?: number, limit?: number, params?: object): Promise<Order[]>;Usage Examples:
const exchange = new ccxt.binance({
apiKey: 'your-api-key',
secret: 'your-secret',
});
// Check specific order
const order = await exchange.fetchOrder('12345', 'BTC/USDT');
console.log(`Order ${order.id}: ${order.status}`);
console.log(`Filled: ${order.filled}/${order.amount}`);
// Get all open orders
const openOrders = await exchange.fetchOpenOrders('BTC/USDT');
openOrders.forEach(order => {
console.log(`${order.side} ${order.amount} at ${order.price} - ${order.status}`);
});
// Get order history
const orderHistory = await exchange.fetchOrders('BTC/USDT', undefined, 50);
const recentOrders = await exchange.fetchClosedOrders('BTC/USDT', Date.now() - 7 * 24 * 60 * 60 * 1000);Fetch personal trade history and execution details.
/**
* Fetch personal trade history
*/
fetchMyTrades(symbol?: string, since?: number, limit?: number, params?: object): Promise<Trade[]>;Usage Examples:
const exchange = new ccxt.binance({
apiKey: 'your-api-key',
secret: 'your-secret',
});
// Get all trades
const allTrades = await exchange.fetchMyTrades();
allTrades.forEach(trade => {
console.log(`${trade.datetime}: ${trade.side} ${trade.amount} ${trade.symbol} at ${trade.price}`);
if (trade.fee) {
console.log(`Fee: ${trade.fee.cost} ${trade.fee.currency}`);
}
});
// Get trades for specific symbol
const btcTrades = await exchange.fetchMyTrades('BTC/USDT');
// Get recent trades
const recentTrades = await exchange.fetchMyTrades('BTC/USDT', Date.now() - 24 * 60 * 60 * 1000, 100);Create advanced order types like stop-loss and take-profit orders.
/**
* Create stop-loss order
*/
createStopLossOrder(
symbol: string,
type: OrderType,
side: OrderSide,
amount: number,
price?: number,
stopPrice?: number,
params?: object
): Promise<Order>;
/**
* Create take-profit order
*/
createTakeProfitOrder(
symbol: string,
type: OrderType,
side: OrderSide,
amount: number,
price?: number,
stopPrice?: number,
params?: object
): Promise<Order>;
/**
* Create order with take-profit and stop-loss
*/
createOrderWithTakeProfitAndStopLoss(
symbol: string,
type: OrderType,
side: OrderSide,
amount: number,
price?: number,
takeProfit?: number,
stopLoss?: number,
params?: object
): Promise<Order>;Usage Examples:
const exchange = new ccxt.binance({
apiKey: 'your-api-key',
secret: 'your-secret',
});
// Stop-loss order
const stopLoss = await exchange.createStopLossOrder(
'BTC/USDT',
'market',
'sell',
0.001,
undefined,
45000 // trigger price
);
// Take-profit order
const takeProfit = await exchange.createTakeProfitOrder(
'BTC/USDT',
'limit',
'sell',
0.001,
55000, // limit price
55000 // trigger price
);
// OCO (One-Cancels-Other) order
const oco = await exchange.createOrderWithTakeProfitAndStopLoss(
'BTC/USDT',
'limit',
'buy',
0.001,
50000, // entry price
55000, // take profit
45000 // stop loss
);Manage positions for margin and futures trading.
/**
* Fetch open positions
*/
fetchPositions(symbols?: string[], params?: object): Promise<Position[]>;
/**
* Fetch specific position
*/
fetchPosition(symbol: string, params?: object): Promise<Position>;
/**
* Set leverage for symbol
*/
setLeverage(leverage: number, symbol?: string, params?: object): Promise<any>;
/**
* Set margin mode (isolated/cross)
*/
setMarginMode(marginMode: string, symbol?: string, params?: object): Promise<any>;
interface Position {
info: any;
id?: string;
symbol: string;
timestamp: number;
datetime: string;
contracts: number;
contractSize: number;
side: 'long' | 'short';
size: number;
notional: number;
leverage: number;
collateral?: number;
initialMargin?: number;
maintenanceMargin?: number;
entryPrice?: number;
markPrice?: number;
unrealizedPnl?: number;
realizedPnl?: number;
percentage?: number;
marginRatio?: number;
marginType?: 'isolated' | 'cross';
}Usage Examples:
const exchange = new ccxt.binance({
apiKey: 'your-api-key',
secret: 'your-secret',
});
// Get all positions
const positions = await exchange.fetchPositions();
positions.forEach(pos => {
if (pos.size !== 0) {
console.log(`${pos.symbol}: ${pos.side} ${pos.size} at ${pos.entryPrice}`);
console.log(`PnL: ${pos.unrealizedPnl} (${pos.percentage}%)`);
}
});
// Get specific position
const btcPosition = await exchange.fetchPosition('BTC/USDT:USDT');
// Set leverage
await exchange.setLeverage(10, 'BTC/USDT:USDT');
// Set margin mode
await exchange.setMarginMode('isolated', 'BTC/USDT:USDT');Handle margin trading operations.
/**
* Add margin to position
*/
addMargin(symbol: string, amount: number, params?: object): Promise<any>;
/**
* Reduce margin from position
*/
reduceMargin(symbol: string, amount: number, params?: object): Promise<any>;
/**
* Borrow margin
*/
borrowMargin(code: string, amount: number, symbol?: string, params?: object): Promise<any>;
/**
* Repay margin
*/
repayMargin(code: string, amount: number, symbol?: string, params?: object): Promise<any>;
/**
* Fetch borrow rates
*/
fetchBorrowRates(params?: object): Promise<Dictionary<any>>;
/**
* Fetch borrow interest history
*/
fetchBorrowInterest(code?: string, symbol?: string, since?: number, limit?: number, params?: object): Promise<any[]>;Usage Examples:
const exchange = new ccxt.binance({
apiKey: 'your-api-key',
secret: 'your-secret',
});
// Add margin to position
await exchange.addMargin('BTC/USDT:USDT', 100); // Add 100 USDT margin
// Reduce margin
await exchange.reduceMargin('BTC/USDT:USDT', 50); // Remove 50 USDT margin
// Borrow for margin trading
await exchange.borrowMargin('USDT', 1000, 'BTC/USDT');
// Repay borrowed amount
await exchange.repayMargin('USDT', 500, 'BTC/USDT');
// Check borrow rates
const borrowRates = await exchange.fetchBorrowRates();
console.log('USDT borrow rate:', borrowRates.USDT);
// Check borrow history
const borrowHistory = await exchange.fetchBorrowInterest('USDT');