Bitget JavaScript SDK

JavaScript SDK Usage

Use framework-neutral JavaScript request and event flows across Node.js-compatible runtimes.

In JavaScript, use the package directly from readable examples. TypeScript remains useful for larger integrations, but the same client patterns work in plain JavaScript.

What This SDK Covers

• Complete Bitget REST API integrations for exchange-specific workflows.
• Robust Bitget WebSocket support for market and account stream handling.
• JavaScript-friendly usage patterns for production integration work.
• Adaptable JavaScript examples & guides under /examples for implementation reference.
• Framework-neutral JavaScript snippets that stay approachable in all JavaScript runtimes.

Install Package

npm install bitget-api
# or
pnpm install bitget-api
yarn add bitget-api

Quickstart REST API Walkthrough

Quickstart REST API Example

import {
  RestClientV2,
  SpotOrderRequestV2,
  WebsocketClientV2,
} from 'bitget-api';

// read from environmental variables
const API_KEY = process.env.API_KEY_COM;
const API_SECRET = process.env.API_SECRET_COM;
const API_PASS = process.env.API_PASS_COM;

// If running from CLI in unix, you can pass env vars as such:
// API_KEY_COM='lkm12n3-2ba3-1mxf-fn13-lkm12n3a' API_SECRET_COM='035B2B9637E1BDFFEE2646BFBDDB8CE4' API_PASSPHRASE_COM='ComplexPa$!23$5^' ts-node examples/rest-trade-spot.ts

// note the single quotes, preventing special characters such as $ from being incorrectly passed

const client = new RestClientV2({
  apiKey: API_KEY,
  apiSecret: API_SECRET,
  apiPass: API_PASS,
  // apiKey: 'apiKeyHere',
  // apiSecret: 'apiSecretHere',
  // apiPass: 'apiPassHere',
});

const wsClient = new WebsocketClientV2({
  apiKey: API_KEY,
  apiSecret: API_SECRET,
  apiPass: API_PASS,
});

function logWSEvent(type: string, data: any) {
  console.log(new Date(), `WS ${type} event: `, data);
}

// simple sleep function
function promiseSleep(milliseconds: number) {
  return new Promise((resolve) => setTimeout(resolve, milliseconds));
}

/** This is a simple script wrapped in a immediately invoked function expression, designed to check for any available BTC balance and immediately sell the full amount for USDT */
(async () => {
  try {
    // Add event listeners to log websocket events on account
    wsClient.on('update', (data) => logWSEvent('update', data));
    wsClient.on('open', (data) => logWSEvent('open', data));
    wsClient.on('response', (data) => logWSEvent('response', data));
    wsClient.on('reconnect', (data) => logWSEvent('reconnect', data));
    wsClient.on('reconnected', (data) => logWSEvent('reconnected', data));
    wsClient.on('authenticated', (data) => logWSEvent('authenticated', data));
    wsClient.on('exception', (data) => logWSEvent('exception', data));

    // Subscribe to private account topics
    // spot private
    // : account updates
    wsClient.subscribeTopic('SPOT', 'account');

    // : order updates (note: symbol is required)
    wsClient.subscribeTopic('SPOT', 'orders', 'BTCUSDT');

    // wait briefly for ws to be ready (could also use the response or authenticated events, to make sure topics are subscribed to before starting)
    await promiseSleep(2.5 * 1000);

    const balanceResult = await client.getSpotAccountAssets();
    const allBalances = balanceResult.data;

    const balanceBTC = allBalances.find(
      (bal) => bal.coin === 'BTC' || bal.coin === 'btc',
    );
    const btcAmount = balanceBTC ? Number(balanceBTC.available) : 0;
    // console.log('balance: ', JSON.stringify(balances, null, 2));
    console.log('BTC balance result: ', balanceBTC);

    if (!btcAmount) {
      console.error('No BTC to trade');
      return;
    }

    console.log(`BTC available: ${btcAmount}`);
    const symbol = 'BTCUSDT';

    const symbolsResult = await client.getSpotSymbolInfo();
    const btcRules = symbolsResult.data.find((rule) => rule.symbol === symbol);
    console.log('btc trading rules: ', btcRules);
    if (!btcRules) {
      return console.log('no rules found for trading ' + symbol);
    }

    const quantity = btcRules.minTradeAmount;

    const order: SpotOrderRequestV2 = {
      symbol: symbol,
      side: 'sell',
      orderType: 'market',
      force: 'gtc',
      size: quantity,
    } as const;

    console.log('submitting order: ', order);

    const sellResult = await client.spotSubmitOrder(order);

    console.log('sell result: ', sellResult);
  } catch (e) {
    console.error('request failed: ', e);
  }
})();

Quickstart WebSocket Walkthrough

Quickstart WebSocket Example

import { DefaultLogger, WebsocketClientV3, WS_KEY_MAP } from 'bitget-api';

(async () => {
  const logger = {
    ...DefaultLogger,
    trace: (...params: any[]) => console.log('trace', ...params),
  };

  const API_KEY = process.env.API_KEY_COM;
  const API_SECRET = process.env.API_SECRET_COM;
  const API_PASS = process.env.API_PASS_COM;

  // If running from CLI in unix, you can pass env vars as such:
  // API_KEY_COM='lkm12n3-2ba3-1mxf-fn13-lkm12n3a' API_SECRET_COM='035B2B9637E1BDFFEE2646BFBDDB8CE4' API_PASSPHRASE_COM='ComplexPa$!23$5^' ts-node examples/ws-private.ts

  const wsClient = new WebsocketClientV3(
    {
      apiKey: API_KEY,
      apiSecret: API_SECRET,
      apiPass: API_PASS,
    },
    logger,
  );

  wsClient.on('update', (data) => {
    console.log('WS raw message received ', data);
    // console.log('WS raw message received ', JSON.stringify(data, null, 2));
  });

  wsClient.on('open', (data) => {
    console.log('WS connection opened:', data.wsKey);
  });
  wsClient.on('response', (data) => {
    console.log('WS response: ', JSON.stringify(data, null, 2));
  });
  wsClient.on('reconnect', ({ wsKey }) => {
    console.log('WS automatically reconnecting.... ', wsKey);
  });
  wsClient.on('reconnected', (data) => {
    console.log('WS reconnected ', data?.wsKey);
  });
  wsClient.on('exception', (data) => {
    console.log('WS error', data);
  });

  // You can subscribe to one topic at a time
  wsClient.subscribe(
    {
      topic: 'account',
      payload: {
        instType: 'UTA', // Note: all account events go on the UTA instType
      },
    },
    WS_KEY_MAP.v3Private, // This parameter points to private or public
  );

  // Note: all account events go on the UTA instType
  const ACCOUNT_INST_TYPE = 'UTA';
  const ACCOUNT_WS_KEY = WS_KEY_MAP.v3Private;

  // Or multiple at once:
  wsClient.subscribe(
    [
      {
        topic: 'account',
        payload: {
          instType: ACCOUNT_INST_TYPE,
        },
      },
      {
        topic: 'position',
        payload: {
          instType: ACCOUNT_INST_TYPE,
        },
      },
      {
        topic: 'fill',
        payload: {
          instType: ACCOUNT_INST_TYPE,
        },
      },
      {
        topic: 'order',
        payload: {
          instType: ACCOUNT_INST_TYPE,
        },
      },
    ],
    ACCOUNT_WS_KEY,
  );

  // Topics are tracked per websocket type
  // The below example will pull a list of subscribed topics on that connection (e.g. all private topics), after a 5 second delay:
  setTimeout(() => {
    const privateTopics = wsClient.getWsStore().getTopics(WS_KEY_MAP.v3Private);

    console.log('private topics currently in state: ', privateTopics);
  }, 5 * 1000);
})();

Quickstart WebSocket API Walkthrough

Quickstart WebSocket API Example

import { DefaultLogger, WebsocketAPIClient } from 'bitget-api';

// function attachEventHandlers<TWSClient extends WebsocketClientV3>(
//   wsClient: TWSClient,
// ): void {
//   wsClient.on('update', (data) => {
//     console.log('raw message received ', JSON.stringify(data));
//   });
//   wsClient.on('open', (data) => {
//     console.log('ws connected', data.wsKey);
//   });
//   wsClient.on('reconnect', ({ wsKey }) => {
//     console.log('ws automatically reconnecting.... ', wsKey);
//   });
//   wsClient.on('reconnected', (data) => {
//     console.log('ws has reconnected ', data?.wsKey);
//   });
//   wsClient.on('authenticated', (data) => {
//     console.log('ws has authenticated ', data?.wsKey);
//   });
// }

(async () => {
  const logger = {
    ...DefaultLogger,
    trace: (...params: any[]) => console.log('trace', ...params),
  };

  const API_KEY = process.env.API_KEY_COM;
  const API_SECRET = process.env.API_SECRET_COM;
  const API_PASS = process.env.API_PASS_COM;

  // If running from CLI in unix, you can pass env vars as such:
  // API_KEY_COM='lkm12n3-2ba3-1mxf-fn13-lkm12n3a' API_SECRET_COM='035B2B9637E1BDFFEE2646BFBDDB8CE4' API_PASSPHRASE_COM='ComplexPa$!23$5^' ts-node examples/ws-private.ts

  const wsClient = new WebsocketAPIClient(
    {
      apiKey: API_KEY,
      apiSecret: API_SECRET,
      apiPass: API_PASS,

      // Whether to use the demo trading wss connection
      // demoTrading: true,

      // If you want your own event handlers instead of the default ones with logs,
      // disable this setting and see the `attachEventHandlers` example below:
      // attachEventListeners: false
    },
    logger, // Optional: inject a custom logger
  );

  // Optional, see above "attachEventListeners". Attach basic event handlers, so nothing is left unhandled
  // attachEventHandlers(wsClient.getWSClient());

  // Optional: prepare the WebSocket API connection in advance.
  // This happens automatically but you can do this early before making any API calls, to prevent delays from a cold start.
  await wsClient.getWSClient().connectWSAPI();

  /**
   * Bitget's WebSocket API be used like a REST API, through this SDK's WebsocketAPIClient. The WebsocketAPIClient is a utility class wrapped around WebsocketClientV3's sendWSAPIRequest() capabilities.
   *
   * Each request sent via the WebsocketAPIClient will automatically:
   * - route via the active WS API connection
   * - return a Promise, which automatically resolves/rejects when a matching response is received
   *
   * Note: this requires V3/UTA API keys!
   */

  /**
   * Place Order
   * https://www.bitget.com/api-doc/uta/websocket/private/Place-Order-Channel#request-parameters
   */
  try {
    const res = await wsClient.submitNewOrder('spot', {
      orderType: 'limit',
      price: '100',
      qty: '0.1',
      side: 'buy',
      symbol: 'BTCUSDT',
      timeInForce: 'gtc',
    });
    /**
      const res = {
        "event": "trade",
        "id": "1750034396082",
        "category": "spot",
        "topic": "place-order",
        "args": [
          {
            "symbol": "BTCUSDT",
            "orderId": "xxxxxxxx",
            "clientOid": "xxxxxxxx",
            "cTime": "1750034397008"
          }
        ],
        "code": "0",
        "msg": "success",
        "ts": "1750034397076"
      };
     */

    console.log(new Date(), 'WS API "submitNewOrder()" result: ', res);
  } catch (e) {
    console.error(new Date(), 'Exception with WS API "submitNewOrder()": ', e);
  }

  /**
   * Batch Place Order Channel
   * https://www.bitget.com/api-doc/uta/websocket/private/Batch-Place-Order-Channel
   */

  try {
    /**
     * Note: batch place will never reject the request, even if all orders were rejected. Check the "code" and "msg" properties for individual orders in the response, to detect batch place errors.
     */
    const res = await wsClient.placeBatchOrders('spot', [
      {
        clientOid: 'xxxxxxxx1',
        orderType: 'limit',
        price: '100',
        qty: '0.1',
        side: 'buy',
        symbol: 'BTCUSDT',
        timeInForce: 'gtc',
      },
      {
        clientOid: 'xxxxxxxx2',
        orderType: 'limit',
        price: '100',
        qty: '0.15',
        side: 'buy',
        symbol: 'BTCUSDT',
        timeInForce: 'gtc',
      },
    ]);

    /**
      const res = {
        "event": "trade",
        "id": "1750035029506",
        "category": "spot",
        "topic": "batch-place",
        "args": [
          {
            "code": "0",
            "msg": "Success",
            "symbol": "BTCUSDT",
            "orderId": "xxxxxxxx",
            "clientOid": "xxxxxxxx"
          },
          {
            "code": "0",
            "msg": "Success",
            "symbol": "BTCUSDT",
            "orderId": "xxxxxxxx",
            "clientOid": "xxxxxxxx"
          }
        ],
        "code": "0",
        "msg": "Success",
        "ts": "1750035029925"
      }
     */

    console.log(new Date(), 'WS API "placeBatchOrders()" result: ', res);
  } catch (e) {
    console.error(
      new Date(),
      'Exception with WS API "placeBatchOrders()": ',
      e,
    );
  }

  /**
   * Cancel Order
   * https://www.bitget.com/api-doc/uta/websocket/private/Cancel-Order-Channel
   */

  try {
    const res = await wsClient.cancelOrder('spot', {
      clientOid: 'xxxxxxxx1',
    });

    /**
      const res = {
        "event": "trade",
        "id": "1750034870205",
        "topic": "cancel-order",
        "args": [
          {
            "orderId": "xxxxxxxx",
            "clientOid": "xxxxxxxx"
          }
        ],
        "code": "0",
        "msg": "Success",
        "ts": "1750034870597"
      }
     */

    console.log(new Date(), 'WS API "cancelOrder()" result: ', res);
  } catch (e) {
    console.error(new Date(), 'Exception with WS API "cancelOrder()": ', e);
  }

  /**
   * Batch Cancel Order
   * https://www.bitget.com/api-doc/uta/websocket/private/Batch-Cancel-Order-Channel
   */

  try {
    const res = await wsClient.cancelBatchOrders('spot', [
      {
        clientOid: 'xxxxxxxx1',
      },
      {
        orderId: '123123123',
      },
    ]);

    /**
      const res = {
        "event": "trade",
        "id": "bb553cc0-c1fa-454e-956d-c96c8d715760",
        "topic": "batch-cancel",
        "args": [
          {
            "code": "0",
            "msg": "Success",
            "orderId": "xxxxxxxxxxxxx"
          },
          {
            "code": "25204",
            "msg": "Order does not exist",
            "orderId": "xxxxxxxxxxxxx"
          }
        ],
        "code": "0",
        "msg": "Success",
        "ts": "1751980011084"
      }
     */

    console.log(new Date(), 'WS API "cancelBatchOrders()" result: ', res);
  } catch (e) {
    console.error(
      new Date(),
      'Exception with WS API "cancelBatchOrders()": ',
      e,
    );
  }

  console.log(new Date(), 'Reached end of example.');
})();

Endpoint Function Reference

Source: View endpoint map source

Bitget JavaScript FAQ

Direct Example Files

Open the example files below if you want the clearest general-purpose starting point for REST API, WebSocket, and authentication workflows in plain JavaScript.

• Bitget REST API example file (Bitget/V2 - Classic/Rest/rest-trade-spot.ts)
• Bitget WebSocket example file (Bitget/V3 - UTA/Websocket/ws-private.ts)
• Bitget WebSocket API example file (Bitget/V3 - UTA/WS-API/ws-api-client-trade.ts)

Reference Links

• npm: bitget-api
• GitHub: bitget-api
• Release feed
• Support and feature requests