QuantScript API Reference

Script Declaration#

mode()

mode(mode_type: "indicator", script_name: "My Script");
mode(mode_type: "live");
mode(mode_type: "backtest", script_name: "My Strategy");

Modes: "indicator", "backtest", "forwardtest", "live". Optional script_name arg.

broker("sim")

broker(adapter: "sim", config: {
  initial_capital: 100000,
  commission: 0.05,
  execution_strategy: "bar-match-hedging"
});

Parameters: initial_capital, commission, commission_type, slippage, leverage, currency, execution_strategy, fill_model, fee_model, margin_model, stop_out_level.

candles()

candles(symbol: "BTCUSD", resolution_type: "1m", bars: 120, adapter: "demotrader.net");

symbol

Data symbol (required, named)

resolution_type

Bar interval (e.g., "1m", "1h", "1d")

bars

Number of bars to fetch

adapter

Data adapter name

ticks()

ticks(symbol: "BTCUSD", adapter: "demotrader.net");
ticks(symbols: ["BTCUSD", "ETHUSD"], adapter: "demotrader.net");

Set the quote stream adapter for real-time tick data. Enables event.onTick() handlers to receive live ticks in forwardtest/live modes.

symbol

One symbol string (required, named)

symbols

Array of symbol strings (required when using multiple symbols, named)

adapter

Quote stream adapter name (required, e.g., "demotrader.net")

Authentication: ticks() requires a broker() declaration — the broker's session token is automatically used for quote stream authentication.

Mode behavior: Active in forwardtest and live modes. Ignored in backtest and indicator modes.

data.loadCandles()#

Load secondary candles from a different symbol/resolution_type. Takes a single object argument. With a callback, evaluates an expression on native bars (like Pine's request.security()). Without a callback, returns a raw FeedAccessor.

Expression evaluation (returns series)

var ethSma = data.loadCandles({ adapter: "demotrader.net", symbol: "ETHUSD", resolution_type: "4h", callback: (c) => ta.sma(c.close, 50) });

// Complex callback with block body
var xauSignal = data.loadCandles({ adapter: "demotrader.net", symbol: "XAUUSD", resolution_type: "1D", callback: (c) => {
  const rsi = ta.rsi(c.close, 14);
  if (rsi === null) return 0;
  return rsi > 70 ? -1 : (rsi < 30 ? 1 : 0);
} });

Raw access (returns FeedAccessor)

var feed = data.loadCandles({ adapter: "demotrader.net", symbol: "ETHUSD", resolution_type: "4h" });
// feed.close, feed.open, feed.high, feed.low, feed.volume

Historical lookback

var prev = ethSma[1];  // previous bar's SMA value

adapter

Data adapter name (required)

symbol

Instrument symbol (required)

resolution_type

Bar interval (required, e.g., "4h", "1D")

callback

Function (c) => expr evaluated on native bars (optional)

gaps

"ffill" | "none" (optional, default "ffill")

All fields go in the single object argument.

Results are forward-filled to the primary resolution_type's timeline. Supports [n] historical lookback on callback results.

broker()

broker(adapter: "demotrader.net", email: "user@example.com", password: "Password@123");

// With allocated_capital for multi-strategy capital isolation
broker(adapter: "demotrader.net", email: "user@example.com", password: "Password@123", config: { allocated_capital: 10000 });

Only required for live trading. Parameters: adapter name, email, password, token, account_id, position_mode.

Virtual Trading Accounts: Set config: { allocated_capital: N } to give this strategy its own isolated balance, equity, and margin tracking when multiple strategies share one broker account. Risk guards (risk()) are enforced against virtual account values. Opt-in — when omitted, broker-wide account values are used. See the guide for details.

risk()

risk(max_position_pct: 20, daily_loss_limit: 3, max_trades_per_day: 10);

Parameters: max_position_pct, daily_loss_limit, daily_profit_target, weekly_loss_limit, max_trades_per_day, max_positions, max_consecutive_losses, max_loss_per_trade, min_balance, min_equity, max_margin_pct, kill_switch.

Execution Model & Events#

event.onCandle(callback)

The primary entry point for bar-by-bar strategy logic.

event.onCandle((candle) => {
    let closePrice = candle.close;
    let highPrice = candle.high;
});

event.onTick(callback)

Fires reactively for each tick/quote received from the quote stream. Requires ticks() declaration and a connected broker() for authentication. The tick object contains symbol, bid, ask, last, and timestamp.

event.onTick((tick) => {
    console.log(`${tick.symbol}: bid=${tick.bid} ask=${tick.ask}`);
});

event.onNewCandle(callback)

Fires when a bar completes.

event.onTimer(callback, intervalMs?)

Fires at a regular time interval. Default: 60000ms.

Broker Event Callbacks

Trading lifecycle events — fired when the broker reports changes to your orders and positions:

• event.onFill(callback) — an order was executed (full or partial fill)
• event.onReject(callback) — the broker rejected an order
• event.onCancel(callback) — a pending order was cancelled or expired
• event.onPositionOpened(callback) — a new position was opened
• event.onPositionChanged(callback) — position modified (SL/TP, size, openPnl)
• event.onPositionClosed(callback) — a position was fully closed (exposes closedPnl)

DataFrame Operations#

Frame Properties

Persistent Variables (var)#

Use var for variables that retain their value across bars.

var highestHigh = 0;
event.onCandle((candle) => {
    if (candle.high > highestHigh) highestHigh = candle.high;
});

Persistent State (state.*)#

Cross-worker persistent storage. Properties survive export/import cycles.

state.entriesToday = 0;
state.lastPrice = 0;

Historical Bar References#

let prevClose = close[1];  // Previous bar's close
let twoAgo = high[2];     // High from 2 bars ago

Technical Analysis (ta.*)#

Null handling: All ta.* functions return null when there is insufficient data. Use ta.nz() to replace nulls.

Moving Averages

Oscillators

Volatility

Trend & Direction

Volume

Utility Functions

Trade Execution (trade.*)#

CCXT-inspired unified trading API. All methods return uniform result objects.

Order Placement

Trade Sizing (size object)

All order methods accept size as an alternative to qty (mutually exclusive). Exactly one field must be set:

// FX: 0.5 lots of EURUSD
trade.buy({ symbol: "EURUSD", size: { lots: 0.5 } });

// Crypto: spend $1000 USDT
trade.buy({ symbol: "BTCUSDT", size: { cash: 1000 } });

// Stocks: risk 2% of equity
trade.buy({ symbol: "AAPL", size: { equity_percent: 2 } });

Order Management

Introspection

Returned fields: id, symbol, side, qty, avgEntryPrice, markPrice, openPnl, closedPnl, marginUsed, leverage, liquidationPrice, stopLoss, takeProfit, strategyId, openedAt, updatedAt.

openPnl is the floating P&L on the still-open exposure (marked at markPrice); closedPnl is the P&L already booked by partial closes. Neither name uses the ambiguous “realised/realized” spelling.

Returned fields: id, name, currency, balance, equity, cash, buyingPower, marginUsed, marginAvailable, openPnl, closedPnl, leverage, positions, marginLevel.

Forming Candle & Live Price (trade.*)#

In forwardtest and live modes the runtime maintains an incomplete (forming) candle that updates with every incoming tick. These builtins expose that real-time data so your strategy can make execution decisions (entry checks, SL/TP placement, position sizing) using the freshest available price — while indicator/signal logic continues to use the confirmed candle.close to avoid repainting.

trade.formingCandle(symbol?)

let bar = trade.formingCandle();
if (bar != null) {
  console.log("Forming close: " + bar.close);
}

Returns the current incomplete candle object, or null if no forming bar exists (e.g., in backtest mode).

symbol

Optional. Symbol to query; defaults to the script’s primary symbol.

Returned fields: time, open, high, low, close, volume, incomplete (always true), symbol.

trade.last(symbol?)

let livePrice = trade.last();
if (livePrice == 0) { livePrice = candle.close; }

Returns the freshest last-traded price: the forming bar’s close if available, otherwise the latest quote’s last. Returns 0 when neither exists (e.g., backtest with no quotes).

symbol

Optional. Symbol to query; defaults to the script’s primary symbol.

Tip: Always include the == 0 fallback so the same script works in both backtest and live modes.

trade.bid(symbol?)

let bid = trade.bid();

Returns the current best bid price from the quote stream. Returns 0 if no quote data is available.

symbol

Optional. Symbol to query; defaults to the script’s primary symbol.

trade.ask(symbol?)

let ask = trade.ask();

Returns the current best ask price from the quote stream. Returns 0 if no quote data is available.

symbol

Optional. Symbol to query; defaults to the script’s primary symbol.

When to Use

Mode behavior: These functions are most useful in forwardtest and live modes. In backtest mode the forming bar is not populated, so trade.last() returns 0 and trade.formingCandle() returns null — hence the fallback pattern.

Strategy Introspection (strategy.*)#

Read-only introspection. Order submission is via trade.*.

Chart Functions (chart.*)#

const isUptrend = close > ta.sma(close, 50);
chart.bgcolor(isUptrend ? "rgba(76,175,80,0.1)" : "rgba(244,67,54,0.1)");

Chart Labels (chart.label.*)

Draw text annotations at specific bar/price locations. Labels can be styled with different visual treatments.

const rsi = ta.rsi(close, 14);
if (rsi > 70) {
  chart.label.new(candleIndex, high, "Overbought", "#f44336", "label_down");
}

Input Functions (input.*)#

const rsiLen = input.int(14, "RSI Length", 2, 50, null, null, null, "RSI");
const stopLoss = input.float(2.0, "Stop Loss %", 0.5, 10.0, 0.5, null, null, "Risk");
const useStop = input.bool(true, "Use Stop Loss", null, null, "Risk");

Event Functions (event.*)#

See Execution Model & Events for core event callbacks.

Built-in Functions#

JavaScript Standard Library#

QuantScript provides full parity with the JavaScript ES6 standard library for the namespaces and types below. They behave identically to their JavaScript counterparts — refer to any JS reference (e.g. MDN) for complete API details.

Quick Examples

// Math
let x = Math.sqrt(144);  // 12

// JSON
let obj = JSON.parse('{"symbol": "BTCUSD", "qty": 0.5}');
console.log(obj.symbol);  // BTCUSD
let text = JSON.stringify(obj);

// Date
let now = Date.now();  // current timestamp in ms

// String methods
let sym = "btcusd".toUpperCase();  // "BTCUSD"

// Array methods
let prices = [100, 102, 98, 105];
let avg = prices.reduce((a, b) => a + b, 0) / prices.length;

JavaScript Gotchas#

QuantScript looks like JavaScript, but is a deliberately constrained DSL.

No do...while loop

Only while, for, and for...of are supported.

No for...in loop

Use for...of over an array of known keys instead.

No classes

No class, extends, super, new, or constructor.

No try/catch/throw

Errors are fatal and handled by the runtime.

No async/await

Scripts are synchronous. No async, await, Promise.

No spread/rest operator

Use arr.concat() instead.

No Set, Map, or WeakRef

Only plain arrays [] and objects {}.

No object destructuring

Array destructuring is supported, but object destructuring is not.

No bitwise operators

No typeof or instanceof

Use x == null to check for null.

No import/export

Scripts are self-contained. All built-ins are available through global namespaces.

No delete operator

No labeled break

break and continue apply to the innermost loop only.

== is strict equality

Unlike JavaScript, == does no type coercion. 0 == "0" is false.

var means something different

In QuantScript, var declares a persistent variable that retains its value across bars.

Two argument conventions

Built-ins take either positional arguments (ta.*, input.*, risk.* — e.g. input.int(14, "RSI", 2, 50)) or a single object argument (trade.* orders, data.loadCandles — e.g. trade.buy({ symbol: "BTCUSD", qty: 1 })). Named arguments are only used in top-level declarations like mode() and candles().

Semicolons are required

Like JavaScript, every statement must end with a semicolon ;.