Building a Crypto Arbitrage Bot in Node.js: A 2026 Engineering Guide

Backtesting Trading Strategies in JavaScript: A Technical Engineering Guide for 2026

Most backtests fail for a boring reason: the simulation does not match production. Different response shapes, hand-rolled signing logic, and pagination bugs create a gap between what your strategy saw in backtest and what it sees live. If you have spent hours normalizing candles from Binance, OKX, and Gate.io before your strategy code even runs, you already know the problem.

This guide walks through a modular backtesting setup in Node.js 26 using the Siebly.io exchange SDKs. The goal is simple: one strategy layer, one normalized data shape, and SDK clients you can swap between historical REST calls and live WebSocket streams without rewriting your core logic. We cover architecture, historical ingestion with packages like binance, bybit-api, @siebly/kraken-api, and gateio-api, then the move to testnet execution with WebsocketAPIClient where the exchange supports it.

• Decouple strategy logic from data ingestion so your backtest clock only exposes data that existed at each simulated moment.
• Use typed Siebly.io SDKs (binance, bitget-api, okx-api, and others) for signing and request shapes instead of maintaining raw REST wrappers per exchange.
• Normalize candle responses into one internal interface before they reach strategy code.
• Reuse the same npm packages for historical REST fetches and live WebsocketClient subscriptions; use WebsocketAPIClient only for command-style calls like order placement.

Backtesting is a simulation of strategy logic against historical market data. It lets you verify that an implementation behaves as expected under past conditions. Understanding What is Backtesting? is the first step in moving from an idea to a production-ready system. The failure mode we see most often is look-ahead bias: the simulation reads a candle or order book update before it would have existed in real time. That invalidates results and creates false confidence.

Node.js 26 is a solid fit for event-driven backtests. You replay time-series data as discrete events on the event loop. The bottleneck is usually I/O and data fidelity, not raw CPU. If your ingestion layer does not mirror exchange response shapes, the backtest is wrong regardless of how clever the strategy is.

import { MainClient } from "binance";
import { RestClientV5 } from "bybit-api";

// Binance: array rows [openTime, open, high, low, close, volume, ...]
const binance = new MainClient();
const binanceKlines = await binance.getKlines({
  symbol: "BTCUSDT",
  interval: "1h",
  limit: 100,
});

// Bybit V5: objects in result.list
const bybit = new RestClientV5();
const bybitKlines = await bybit.getKline({
  category: "spot",
  symbol: "BTCUSDT",
  interval: "60",
  limit: 100,
});

A production-grade engine separates three layers:

• Data provider - fetches and normalizes candles, trades, or book snapshots.
• Strategy processor - pure logic: signals in, intended orders out.
• Execution simulator - models fills, fees, and slippage.

export interface Candle {
  openTime: number;
  open: number;
  high: number;
  low: number;
  close: number;
  volume: number;
}

export interface DataProvider {
  getCandles(symbol: string, from: number, to: number): Promise;
}

export interface Strategy {
  onCandle(candle: Candle): void;
}

A monolithic script that fetches, signals, and simulates in one file is hard to test and painful to port to live trading. Define a strategy interface and inject the data provider. That pattern also supports the supervision and control practices you need before going live: you can unit test strategy code in isolation.

Use a deterministic clock in backtests. Live systems use Date.now(). Backtests advance simulated time only when the engine feeds the next event. That is how you prevent look-ahead bias.

import { MainClient } from "binance";
import type { Candle, DataProvider } from "./types.js";

export class BinanceDataProvider implements DataProvider {
  private client = new MainClient();

  async getCandles(
symbol: string,
from: number,
to: number,
  ): Promise {
const rows = await this.client.getKlines({
symbol,
interval: "1h",
startTime: from,
endTime: to,
limit: 1000,
});

return rows.map((row) => ({
openTime: row[0],
open: parseFloat(row[1]),
high: parseFloat(row[2]),
low: parseFloat(row[3]),
close: parseFloat(row[4]),
volume: parseFloat(row[5]),
}));
  }
}

Rolling your own REST layer across exchanges accumulates debt fast. Gate.io signing (gateio-api) differs from BitMart (bitmart-api, which also expects an API memo on private routes). Coinbase Advanced Trade uses JWT-based auth via coinbase-api. Maintaining all of that by hand pulls focus away from strategy work.

The published packages handle it:

import { RestClientV5 } from "bybit-api";

const client = new RestClientV5({
  key: process.env.BYBIT_API_KEY,
  secret: process.env.BYBIT_API_SECRET,
  // testnet: true,
});

Here is a practical five-step pattern for historical ingestion:

• Install the SDK for your exchange (npm install binance, npm install bitget-api, etc.).
• Define the time range and interval in Unix milliseconds.
• Paginate. Most venues return 100 to 1,000 candles per request. Walk backward or forward until the range is covered.
• Normalize into your internal Candle interface.
• Persist to Parquet, SQLite, or a time-series store for fast replay.

import { MainClient } from "binance";
import type { Candle } from "./types.js";

const client = new MainClient();

async function fetchKlines(
  symbol: string,
  interval: string,
  startTime: number,
  endTime: number,
): Promise {
  const candles: Candle[] = [];
  let cursor = startTime;

  while (cursor  setTimeout(resolve, 200));
  }

  return candles;
}

Example paginated fetch with binance:

The same structure works for other SDKs. Swap the client and method:

ts title="Imported example" import { SpotClient } from "@siebly/kraken-api"; const kraken = new SpotClient(); const ohlc = await kraken.getCandles({ pair: "XBTUSD", interval: 60, }); import { RestClient } from "gateio-api"; const gate = new RestClient(); const gateCandles = await gate.getSpotCandles({ currency_pair: "BTC_USDT", interval: "1h", from: Math.floor(startTime / 1000), to: Math.floor(endTime / 1000), });

Note Gate.io candle from/to in seconds, not milliseconds. Normalization belongs in your provider layer.

The jump from simulation to testnet exposes architectural shortcuts. If live ingestion uses different types or signing logic than your backtest, results will not carry over. Keep the same npm packages and normalize to the same internal types in both modes. Swap the data provider implementation: historical getKlines in backtest, WebsocketClient subscriptions live.

For market data streams, use WebsocketClient and subscribe to klines, trades, or order books. For order commands over a persistent connection, use WebsocketAPIClient. That class wraps the WebSocket API with promise-based methods: call submitNewOrder(), await the response. It is not for passive subscriptions.

Supported on Binance, Bybit, OKX, Gate.io, Bitget, KuCoin, and Kraken (spot only for Kraken's WebsocketAPIClient).

import { WebsocketAPIClient } from "bybit-api";

const wsApi = new WebsocketAPIClient({
  key: process.env.BYBIT_API_KEY,
  secret: process.env.BYBIT_API_SECRET,
  testnet: true,
});

const order = await wsApi.submitNewOrder({
  category: "linear",
  symbol: "BTCUSDT",
  orderType: "Limit",
  qty: "0.001",
  side: "Buy",
  price: "50000",
});

console.log(order);

For live market data on the same exchange, use WebsocketClient separately:

ts title="Imported example" import { WebsocketClient } from "okx-api"; const ws = new WebsocketClient(); ws.on("update", (data) => { console.log("market update", data); }); ws.subscribe({ channel: "candle1H", instId: "BTC-USDT", });

Use testnet or demo keys first. Disable withdrawals on automation keys. Keep secrets in environment variables.

Reliable backtesting in JavaScript comes down to modularity: strategy code that does not know which exchange produced a candle, a deterministic clock, and one normalization layer across venues. Siebly.io ships production SDKs for Binance, Bybit, OKX, Kraken, KuCoin, Bitget, Gate.io, BitMart, and Coinbase. They are TypeScript-first and ship with examples under each repo's examples/ folder.

You should not need a rewrite to go from backtest to testnet. Same packages, same types, different data provider. Explore Siebly.io JavaScript SDKs for Professional Exchange Integration