The backtest console: test trading strategies with code

Safe by design. Your script runs only in your browser, in a sandbox with no internet access: it can read the candles it is given and nothing else (not your account, not this site, not other websites). Nothing you write is run on our servers.

Start in one minute

1. Open any chart, for example EURUSD, and pick the timeframe you want to test (H1, D1…).
2. Press Strategy in the chart's toolbar. The console opens under the chart.
3. Choose a built-in strategy, for example Moving average crossover. It runs at once: arrows on the chart mark every entry and exit.
4. Change an input (say the slow average from 30 to 50): the test runs again by itself.
5. Read Overview for the totals, Trades for each trade, Equity curve for the account over time.
6. Press Edit a copy to turn it into your own script, change it, and press Run test (or Ctrl+Enter).

The console, part by part

Settings

Reading the results

The Trades tab lists every trade with its direction, entry and exit time and price, size, profit in money and %, how many candles it lasted, why it closed (signal, stop loss, take profit, reversed, still open at the end) and your comment. Download CSV exports it for a spreadsheet. The Equity curve shows the account against buy and hold. The Log shows what your script wrote with log().

How orders are filled

• No looking ahead. An order placed in onBar(i) is filled at the open of the next candle (i + 1). A strategy can never trade on a price it could not have known.
• Stops inside the candle. Stop loss and take profit are checked against each candle's high and low. If both could have been reached in the same candle, the stop counts (the cautious assumption). A gap through a stop fills at the open, as in real markets.
• One position at a time. long() while short closes the short and opens a long ("reversed"); long() while already long only updates the stops you pass.
• Costs on every fill. Slippage moves each fill price against you; commission is charged on entry and exit.
• The end. A trade still open after the last candle is closed at the last close and marked "still open at the end".

Writing your own strategy

A strategy is a short JavaScript program in two parts:

1. The top runs once: read your inputs with input(), calculate whole series with ta.* or ind(), and draw them with plot().
2. function onBar(i) { … } runs for every candle, oldest first. i is the candle's number (0 = the oldest). Decide here: long(), short(), exit(), or nothing.

// 1. once: inputs and series
const len = input("Average length", 50, { min: 5, max: 400 });
const avg = ta.sma(close, len);           // one value per candle
plot(avg, "SMA " + len, "#2F80ED");       // drawn on the price chart

// 2. every candle
function onBar(i) {
  if (avg[i] == null) return;             // the first len - 1 values are null (warming up)
  if (position === 0 && close[i] > avg[i]) long();
  if (position > 0 && close[i] < avg[i]) exit("below the average");
}

Things worth knowing from the start:

• Series are arrays, one value per candle, oldest first: close[i] is this candle's close, close[i - 1] the one before. Calculated series are null until they have enough candles; check before using them.
• Inside onBar(i) you can read candles up to i only. close[i + 1] stops the test with an error: that would be peeking into the future.
• Use const and let as usual; your own variables keep their values between candles (handy for a trailing stop).
• Prices are in the chart's own units (for EURUSD 1.0850, for gold 2650.40); time is UTC seconds.

Reference

Candles and the current state

Inputs

Up to 30 inputs. Their values are saved with the strategy and travel with it when you publish it in an idea.

Calculations (ta.*)

src is any series: close, high, another result, or your own array. Every function returns a new array; nothing changes the candles.

Signals

Orders

Output

All 71 chart indicators in code: ind()

ind(id, inputs) calculates any indicator of the chart exactly as the chart does. It returns its first line as a series; all lines are in .lines and their names in .names. Inputs you leave out take the default shown. method is one of SMA, EMA, SMMA, LWMA; price one of close, open, high, low, median, typical, weighted.

const st = ind("stoch", { k: 14, d: 3, slowing: 3 });   // st = %K, st.lines[1] = %D
const ich = ind("ichimoku");                            // ich.names: Tenkan, Kijun, Span A, Span B, Chikou
const kijun = ich.lines[1];

Examples

Each example runs as it is: press Copy, open the console, choose New script…, paste and press Run test. Results depend on the ticker, timeframe and period; the examples teach the technique, they are not recommendations.

const len = input("Average length", 50, { min: 5, max: 400 });
const avg = ta.sma(close, len);
plot(avg, "SMA " + len, "#2F80ED");

function onBar(i) {
  if (avg[i] == null) return;                 // still warming up
  if (position === 0 && close[i] > avg[i]) long({ comment: "close above the average" });
  if (position > 0 && close[i] < avg[i]) exit("close below the average");
}

const fast = ta.ema(close, input("Fast EMA", 12, { min: 2, max: 200 }));
const slow = ta.ema(close, input("Slow EMA", 26, { min: 3, max: 400 }));
plot(fast, "Fast", "#2F80ED");
plot(slow, "Slow", "#E39B2D");

function onBar(i) {
  if (ta.crossover(fast, slow, i)) long();
  if (ta.crossunder(fast, slow, i)) short();
}

const r = ta.rsi(close, 14);
const sl = input("Stop loss %", 1.5, { min: 0.1, max: 20, step: 0.1 });
const tp = input("Take profit %", 3, { min: 0.1, max: 50, step: 0.1 });

function onBar(i) {
  if (position !== 0) return;                 // one trade at a time
  if (ta.crossover(r, 30, i)) long({ slPct: sl, tpPct: tp, comment: "RSI back above 30" });
  if (ta.crossunder(r, 70, i)) short({ slPct: sl, tpPct: tp, comment: "RSI back below 70" });
}

const a = ta.atr(14);
const hi = ta.highest(high, 20);
const mult = input("Stop (ATR multiple)", 2, { min: 0.5, max: 6, step: 0.5 });

function onBar(i) {
  if (i < 1 || a[i] == null || hi[i - 1] == null || position !== 0) return;
  if (close[i] > hi[i - 1]) {                  // a new 20-candle high
    const stop = close[i] - mult * a[i];
    const target = close[i] + 2 * mult * a[i];
    long({ sl: stop, tp: target, comment: "breakout, risk " + (mult * a[i]).toFixed(5) });
  }
}

const a = ta.atr(14);
const fast = ta.ema(close, 20), slow = ta.ema(close, 50);
let stop = null;

function onBar(i) {
  if (a[i] == null || slow[i] == null) return;
  if (position === 0) {
    stop = null;
    if (ta.crossover(fast, slow, i)) long({ comment: "trend up" });
    return;
  }
  const candidate = close[i] - 3 * a[i];
  if (stop === null || candidate > stop) {     // only ever raise it
    stop = candidate;
    stopLoss(stop);
  }
}

const adx = ind("adx", { period: 14 });      // .lines[0] ADX, [1] +DI, [2] -DI
const plusDI = adx.lines[1], minusDI = adx.lines[2];
const m = ta.macd(close, 12, 26, 9);
const minAdx = input("Minimum ADX", 25, { min: 10, max: 50 });

function onBar(i) {
  if (adx[i] == null || adx[i] < minAdx) return;
  if (ta.crossover(m.macd, m.signal, i) && plusDI[i] > minusDI[i]) long();
  if (ta.crossunder(m.macd, m.signal, i) && minusDI[i] > plusDI[i]) short();
}

const b = ta.bb(close, input("Period", 20, { min: 5, max: 200 }), input("Width", 2, { min: 0.5, max: 4, step: 0.1 }));
plot(b.upper, "Upper", "#8E44AD");
plot(b.lower, "Lower", "#8E44AD");

function onBar(i) {
  if (b.middle[i] == null) return;
  if (position === 0 && close[i] < b.lower[i]) long({ comment: "below the lower band" });
  else if (position === 0 && close[i] > b.upper[i]) short({ comment: "above the upper band" });
  else if (position > 0 && close[i] >= b.middle[i]) exit("middle band");
  else if (position < 0 && close[i] <= b.middle[i]) exit("middle band");
}

const from = input("Start hour (UTC)", 7, { min: 0, max: 23 });
const to = input("End hour (UTC)", 16, { min: 1, max: 24 });
const fast = ta.sma(close, 10), slow = ta.sma(close, 30);

function onBar(i) {
  const hour = new Date(time[i] * 1000).getUTCHours();
  if (position !== 0 && hour >= 20) { exit("end of the day"); return; }
  if (hour < from || hour >= to) return;
  if (ta.crossover(fast, slow, i)) long();
  if (ta.crossunder(fast, slow, i)) short();
}

const k = input("Range multiple", 0.5, { min: 0.1, max: 2, step: 0.1 });
const range = high.map((h, i) => (i ? high[i - 1] - low[i - 1] : null));   // the previous candle's range
const trigger = open.map((o, i) => (range[i] == null ? null : o + k * range[i]));
plot(trigger, "Trigger", "#16A085");

function onBar(i) {
  if (trigger[i] == null) return;
  if (position === 0 && close[i] > trigger[i]) {
    long({ slPct: 1, comment: "close above open + " + k + " x range" });
    log("signal at", close[i], "trigger", trigger[i]);
  } else if (position > 0 && i - entryBar >= 3) {
    exit("held 3 candles");
  }
}

const a = ta.atr(14);
const riskPct = input("Risk per trade %", 1, { min: 0.1, max: 5, step: 0.1 });
const fast = ta.ema(close, 20), slow = ta.ema(close, 50);

function onBar(i) {
  if (a[i] == null || slow[i] == null || position !== 0) return;
  if (ta.crossover(fast, slow, i)) {
    const stopDistance = 2 * a[i];
    const qty = (equity * riskPct / 100) / stopDistance;
    long({ qty: qty, sl: close[i] - stopDistance, tp: close[i] + 3 * stopDistance,
           comment: "risk " + riskPct + "%" });
  }
}

const trend = ta.sma(close, 200), fast = ta.ema(close, 20), r = ta.rsi(close, 14);

function onBar(i) {
  if (trend[i] == null || i < 5) return;
  let dipped = false;
  for (let k = 0; k < 5; k++) if (r[i - k] != null && r[i - k] < 40) dipped = true;
  if (position === 0 && close[i] > trend[i] && dipped && ta.crossover(close, fast, i)) {
    long({ slPct: 2, tpPct: 4, comment: "pullback bought" });
  }
}

Errors and how to fix them

Testing that you can trust

• Add your costs. A strategy that trades often can look great with zero costs and lose money with a realistic spread. Always fill in slippage (the spread) and commission.
• Use enough trades. Under about 30 trades, the numbers are mostly chance. Load more candles or use a lower timeframe.
• Do not fit the past. Trying many inputs until the result is perfect finds the noise of that period, not a rule that works. Tune on one part of the history, then check the same inputs on another period and on a few other tickers.
• Compare with buy and hold and look at the drawdown, not only the profit.
• Watch the extremes. If one or two trades make all the profit, the strategy depends on luck.
• Practise before risking money. Run the strategy forward on paper trading or with bar replay, and set alerts for its signals.

Back-tests use past bid candles and ignore swaps, financing and spreads that change with the market. Past results do not guarantee future results. This is not investment advice.

Save, share, publish

• Save (signed in) keeps up to 50 strategies with their inputs and settings; they appear in the list on every chart.
• Publish an idea from the chart and attach a strategy: readers can open your chart and run the strategy themselves, with your inputs. See Ideas.
• Share your analysis with a team in a club.
• Download CSV on the Trades tab exports the trades to a spreadsheet.
• For heavier research, pull the same candles with the price API (GET /bars) into Python, R or Excel.

Limits

Questions