How to Backtest a Pine Script Strategy

TradingLead can backtest Pine Script strategy() scripts, the same kind of script you might use in TradingView's Strategy Tester, on your TradingLead chart. This guide covers getting a script running, configuring it and reading the results honestly.

How Pine strategies run on TradingLead

TradingLead supports a documented subset of Pine v5/v6 (TLScript-Pine). A strategy() script runs in a Pine broker emulator, and its actual fills, entry lots, allocated fees and candle-close equity are carried into the same report used for Python strategies. TradingLead does not re-simulate your signals with a different fill model.

This is not TradingView parity. Function coverage, fill details and edge cases can differ, so a script may produce different numbers than on another platform. For indicator-only scripts, see Run a Pine Script indicator and the Pine Script feature page.

Step 1: Open the chart

Go to tradinglead.in/charts and choose the feed, symbol and interval. The backtest uses this chart's data source.

Step 2: Write or paste the strategy in Indicator Studio

Open Indicator Studio, switch to Pine, and either load the bundled SMA crossover strategy example or paste your own script. It must call strategy(...) (not indicator(...)). Studio detects strategy scripts from the code itself.

Compile the script. If you get errors, check whether you used functions outside the supported subset, then simplify or replace them. Save the script so you can reuse it.

Step 3: Apply & backtest

For a strategy script, Studio's main action becomes Apply & backtest. It hands the exact draft, its typed inputs and per-run settings to the Backtesting panel.

Alternatively, open the Backtesting tab, set the language to TLScript-Pine strategy() and pick your saved Pine source.

Step 4: Configure inputs and execution settings

• Inputs: your script's input.* values, keyed by declared variable name.
• Execution settings (optional overrides): initial capital, default quantity type/value, commission type/value, slippage (whole ticks), pyramiding, long/short margin, process_orders_on_close and limit-fill verification ticks.

Leave an override empty to keep the value declared in your strategy() call. Set commission and slippage to values that reflect your broker and the instrument's liquidity.

Choose the history range: up to 20,000 closed candles, or explicit dates. If the source can't supply the range, the run fails rather than testing fewer candles.

Step 5: Run and review

Run the backtest and wait for completed. Then review:

• Summary metrics and Analytics: net P&L, max drawdown, win rate, profit factor, expectancy and buy-and-hold comparison.
• Pine strategy report: the emulator's own summary. Its drawdown may include intrabar extremes, while the main report uses candle-close equity.
• Execution assumptions: the panel shows that results come from the Pine strategy() emulator.
• Chart: actual fill markers plus the plots and drawings your script produced from the same execution. Toggle script plots and drawings separately from trade markers.

Fill behaviour to know

• Market orders normally fill at the next candle's open; with process_orders_on_close an extra closing-price order pass runs after each candle.
• Slippage applies to market and stop fills, not limit fills.
• Stop-limit orders activate their limit leg only after the stop is crossed.
• calc_on_every_tick, calc_on_order_fills, calc_on_every_history_tick, use_bar_magnifier and fill_orders_on_standard_ohlc are rejected, not ignored.

Step 6: Go further

• Optimize declared inputs with the Strategy Optimizer using holdout or walk-forward splits.
• Branch a manual paper trading replay from the completed run. Pine branches start a new flat shared-engine account that does not inherit Pine costs or margin, and automatic Pine replay/forward execution is unsupported.
• Save the run to compare it later with other runs on the same candles.

Limitations

• Supported Pine is a documented v5/v6 subset. Some TradingView scripts won't compile or may behave differently.
• Pine backtests are vectorized only. Source lookahead (for example, misuse of higher-timeframe requests) remains the author's responsibility.
• Historical fills are candle-based, not tick-accurate.
• Backtests are simulations on past data. They are not investment advice and don't guarantee future results.