Poloniex Node.js API

Node.js library for Poloniex.

Installation

npm install poloniex-node-api
Copy

Usage

Legacy API

See here

PublicClient

import { PublicClient } from "poloniex-node-api";
const client = new PublicClient();
Copy

• getMarkets

const markets = await client.getMarkets();
Copy

• getMarket

const symbol = "ETH_BTC";
const volume = await client.getMarket({ symbol });
Copy

• getCurrency

const currency = "BNB";
const currency_info = await client.getCurrency({ currency });
Copy

or

const includeMultiChainCurrencies = true;
const all = await client.getCurrency({ includeMultiChainCurrencies });
Copy

• getSystemTime

const time = await client.getSystemTime();
Copy

• getPrices

const prices = await client.getPrices();
Copy

• getPrice

const symbol = "ETH_BTC";
const price = await client.getPrice({ symbol });
Copy

• getMarkPrices

const prices = await client.getMarkPrices();
Copy

• getMarkPrice

const symbol = "ZEC_USDT";
const price = await client.getMarkPrice({ symbol });
Copy

• getMarkPriceComponents

const symbol = "ZEC_USDT";
const prices = await client.getMarkPriceComponents({ symbol });
Copy

• getOrderBook

const symbol = "ETH_BTC";
const limit = 5;
const scale = "0.01";
const book = await client.getOrderBook({ symbol, limit, scale });
Copy

• getCandles

const symbol = "ETH_BTC";
const interval = "HOUR_1";
const limit = 2;
const endTime = Date.now();
const startTime = endTime - 1000 * 60 * 60 * 24;
const candles = await client.getOrderBook({
  symbol,
  interval,
  limit,
  startTime,
  endTime,
});
Copy

• getPublicTrades

const symbol = "ETH_BTC";
const limit = 2;
const trades = await client.getPublicTrades({ symbol, limit });
Copy

• getTickers

const tickers = await client.getTickers();
Copy

• getTicker

const symbol = "ETH_BTC";
const ticker = await client.getTicker({ symbol });
Copy

• getCollateral

const currency = "ETH";
const collateral = await client.getCollateral({ currency });
Copy

or

const all = await client.getCollateral();
Copy

• getBorrowRates

const symbol = "ETH_BTC";
const ticker = await client.getTicker({ symbol });
Copy

AuthenticatedClient

import { AuthenticatedClient } from "poloniex-node-api";
const key = "poloniex-api-key";
const secret = "poloniex-api-secret";
const client = new AuthenticatedClient({ key, secret });
Copy

Accounts

• getAccounts

const accounts = await client.getAccounts();
Copy

• getAccountBalances

const balances = await client.getAccountBalances();
Copy

• getAccountActivity

const activity = await client.getAccountActivity();
Copy

• transfer

const currency = "USDT";
const amount = "10.5";
const fromAccount = "SPOT";
const toAccount = "FUTURES";
const { transferId } = await client.transfer({
  currency,
  amout,
  fromAccount,
  toAccount,
});
Copy

• getAccountTransfers

const transfers = await client.getAccountTransfers();
Copy

• getFeeInfo

const fee_info = await client.getFeeInfo();
Copy

Wallets

• getWallets

const wallets = await client.getWallets();
Copy

• getWalletsActivity

const { deposits, withdrawals } = await client.getWalletsActivity();
Copy

• newAddress

const { address } = await client.newAddress();
Copy

• withdraw

const { withdrawalRequestsId } = await client.withdraw();
Copy

Margin

• getMargin

const info = await client.getMargin();
Copy

• getBorrowStatus

const status = await client.getBorrowStatus();
Copy

• getMaxSize

const size = await client.getMaxSize();
Copy

Orders

• createOrder

const symbol = "BTC_USDT";
const type = "LIMIT";
const quantity = "100";
const side = "BUY";
const price = "40000.50000";
const timeInForce = "IOC";
const clientOrderId = "1234Abc";
const { id, clientOrderId } = await client.createOrder({
  symbol,
  type,
  quantity,
  side,
  price,
  timeInForce,
  clientOrderId,
});
Copy

or

const symbol = "BTC_USDT";
const quantity = "100";
const side = "BUY";
const { id } = await client.createOrder({ symbol, quantity, side });
Copy

• createOrders

const orders = [
  { symbol: "BTC_USDT", amount: "100", side: "BUY" },
  {
    symbol: "BTC_USDT",
    type: "LIMIT",
    quantity: "100",
    side: "BUY",
    price: "40000.50000",
    timeInForce: "IOC",
    clientOrderId: "1234Abc",
  },
  { symbol: "ETH_USDT", amount: "1000", side: "BUY" },
  {
    symbol: "TRX_USDT",
    type: "LIMIT",
    quantity: "15000",
    side: "SELL",
    price: "0.0623423423",
    timeInForce: "IOC",
    clientOrderId: "456Xyz",
  },
];
const response = await client.createOrders(orders);
Copy

• [replaceOrder](https://docs.poloniex.com/#authenticated-endpoints-orders-cancel-replace-order

const id = "234235233423";
const price = "18000";
const clientOrderId = "1234";
const response = await client.replaceOrder({ id }, { price, clientOrderId });
Copy

or

const clientOrderId = "1234Abc";
const price = "18000";
const quantity = "20";
const response = await client.replaceOrder(
  { clientOrderId },
  { price, quantity },
);
Copy

• getOpenOrders

const symbol = "ELON_USDC";
const side = "SELL";
const direction = "PRE";
const limit = 10;
const orders = await client.getOpenOrders({ symbol, side, direction, limit });
Copy

or

const orders = await client.getOpenOrders();
Copy

• getOrder

const id = "21934611974062080";
const order = await client.getOrder({ id });
Copy

or by clientOrderId

const clientOrderId = "123";
const order = await client.getOrder({ clientOrderId });
Copy

• cancelOrder

const id = "21934611974062080";
const order = await client.cancelOrder({ id });
Copy

or by clientOrderId

const clientOrderId = "123";
const order = await client.cancelOrder({ clientOrderId });
Copy

• cancelOrders

const orders = [{ id: "12345" }, { clientOrderId: "myId-1" }];
const results = await client.cancelOrders(orders);
Copy

• cancelAllOrders

const symbols = ["BTC_USDT", "ETH_USDT"];
const accountTypes = ["SPOT"];
const results = await client.cancelAllOrders({ symbols, accountTypes });
Copy

or (to cancel all orders)

const results = await client.cancelAllOrders();
Copy

• killSwitch

const timeout = 60;
const status = await client.killSwitch({ timeout });
Copy

• getKillSwitch

const status = await client.getKillSwitch();
Copy

Smart Orders

• createSmartOrder

const symbol = "BTC_USDT";
const side = "BUY";
const type = "STOP_LIMIT";
const quantity = "100";
const price = "60100.00";
const timeInForce = "FOK";
const stopPrice = "60000.00";
const clientOrderId = "999999910";
const { id, clientOrderId } = await client.createSmartOrder({
  symbol,
  side,
  type,
  quantity,
  price,
  timeInForce,
  stopPrice,
  clientOrderId,
});
Copy

• [replaceSmartOrder](https://docs.poloniex.com/#authenticated-endpoints-smart-orders-cancel-replace-order

const id = "234235233423";
const stopPrice = "18000";
const clientOrderId = "1234Abc";
const response = await client.replaceOrder(
  { id },
  { stopPrice, clientOrderId },
);
Copy

or by clientOrderId

const clientOrderId = "1234Abc";
const price = "18000";
const quantity = "20";
const response = await client.replaceOrder(
  { clientOrderId },
  { stopPrice, quantity },
);
Copy

• getOpenSmartOrders

const limit = 10;
const orders = await client.getOpenSmartOrders({ limit });
Copy

or

const orders = await client.getOpenSmartOrders();
Copy

• getSmartOrder

const id = "14368195657859072";
const order = await client.getSmartOrder({ id });
Copy

or by clientOrderId

const clientOrderId = "18113";
const order = await client.getSmartOrder({ clientOrderId });
Copy

• cancelSmartOrder

const id = "9876543";
const order = await client.cancelSmartOrder({ id });
Copy

or by clientOrderId

const clientOrderId = "88888";
const order = await client.cancelSmartOrder({ clientOrderId });
Copy

• cancelSmartOrders

const orders = [{ id: "12345" }, { clientOrderId: "myId-1" }];
const results = await client.cancelSmartOrders(orders);
Copy

• cancelAllSmartOrders

const symbols = ["BTC_USDT", "ETH_USDT"];
const accountTypes = ["SPOT"];
const results = await client.cancelAllSmartOrders({ symbols, accountTypes });
Copy

or (to cancel all orders)

const results = await client.cancelAllSmartOrders();
Copy

Order history

• getOrders

const type = ["MARKET", "LIMIT"];
const side = "BUY";
const symbol = "TRX_USDC";
const states = ["FILLED", "PARTIALLY_CANCELED"];
const limit = 10;
const hideCancel = true;
const startTime = 1649106321040;
const endTime = 1649427963598;
const orders = await client.getOrders({
  type,
  side,
  symbol,
  states,
  limit,
  hideCancel,
  startTime,
  endTime,
});
Copy

Trades

• getTrades

const limit = 10;
const endTime = 1648635115535;
const startTime = endTime - 1000 * 60 * 60;
const direction = "PRE";
const symbols = ["BTC_USDT", "ETH_USDT"];
const trades = await client.getTrades({
  limit,
  startTime,
  endTime,
  direction,
  symbols,
});
Copy

• getOrderTrades

const id = "30249408733945856";
const trades = await client.getOrderTrades({ id });
Copy

WebSocketClient

const key = "<POLONIEX API KEY>";
const secret = "<POLONIEX API SECRET>";
const client = new WebSocketClient({ key, secret })
  .on("message", (msg) => {
    console.log("Message:\t", msg);
  })
  .on("error", (error) => {
    console.log("Error:\t", error);
  });
Copy

• connectPublicWS

await client.connectPublicWS();
Copy

• connectPrivateWS

await client.connectPrivateWS();
Copy

• disconnectPublicWS

await client.disconnectPublicWS();
Copy

• disconnectPrivateWS

await client.disconnectPrivateWS();
Copy

• auth

await client.auth();
Copy

• pingPublic

const ac = new AbortController();
setTimeout(() => {
  ac.abort();
}, 10000).unref();
await client.pingPublic({ signal: ac.signal });
Copy

• pingPrivate

await client.pingPrivate();
Copy

• unsubscribePublic

await client.unsubscribePublic();
Copy

• unsubscribePrivate

await client.unsubscribePrivate();
Copy

• getPublicSubscriptions

const { subscriptions } = await client.getPublicSubscriptions();
Copy

• getPrivateSubscriptions

const { subscriptions } = await client.getPrivateSubscriptions();
Copy

• send

const payload = {
  event: "subscribe",
  channel: ["candles_minute_1", "ticker"],
  symbols: ["BTC_USDT", "ETH_USDT"],
};
await client.send(payload, "public");
Copy

or

const payload = {
  event: "subscribe",
  channel: ["orders", "balances"],
  symbols: ["all"],
};
await client.send(payload, "private");
Copy

Candlesticks

• subscribeCandles

await client.subscribeCandles();
Copy

• unsubscribeCandles

await client.unsubscribeCandles();
Copy

• candles

const channel = "candles_day_1";
for await (const candle of client.candles()) {
  console.log(candle);
}
Copy

Trades

• subscribeTrades

const symbols = ["BTC_USDT", "ETH_USDT"];
await client.subscribeTrades({ symbols });
Copy

• unsubscribeTrades

const symbols = ["BTC_USDT"];
await client.unsubscribeTrades({ symbols });
Copy

• trades

for await (const trade of client.trades()) {
  console.log(trade);
}
Copy

Ticker

• subscribeTicker

const symbols = "all";
await client.subscribeTicker({ symbols });
Copy

• unsubscribeTicker

const symbols = "all";
await client.unsubscribeTicker({ symbols });
Copy

• tickers

for await (const ticker of client.tickers()) {
  console.log(ticker);
}
Copy

Book

• subscribeBook

await client.subscribeBook();
Copy

• unsubscribeBook

const symbols = "all";
await client.unsubscribeBook({ symbols });
Copy

• books

const depth = 10;
for await (const book of client.books({ depth })) {
  console.log(book);
}
Copy

Book Level 2

• subscribeLv2Book

const symbols = ["BTC_USDT"];
await client.subscribeLv2Book({ symbols });
Copy

• unsubscribeLv2Book

const symbols = "all";
await client.unsubscribeLv2Book({ symbols });
Copy

• booksLv2

for await (const book of client.booksLv2()) {
  console.log(book);
}
Copy

Orders

• subscribeOrders

const symbols = "all";
await client.subscribeOrders({ symbols });
Copy

• unsubscribeOrders

const symbols = "all";
await client.unsubscribeOrders({ symbols });
Copy

• orders

for await (const order of client.orders()) {
  console.log(order);
}
Copy

Balances

• subscribeBalances

await client.subscribeBalances();
Copy

• unsubscribeBalances

await client.unsubscribeBalances();
Copy

• balances

for await (const balance of client.balances()) {
  console.log(balance);
}
Copy

Test

npm test
Copy

Coverage

npm run coverage
Copy