Short answer: The TradingView Strategy Tester, now called the strategy report, is the panel under the chart that simulates a Pine Script strategy's orders and shows its metrics, trade list and settings. Its results depend on initial capital, order size, commission, slippage, pyramiding and fill settings, and it stays empty when the script is an indicator or never places an order. As of October 2026, deep backtesting beyond the bars loaded on the chart requires a Premium or Ultimate plan.
Recompute these metrics from your own exported figures: Win rate and expectancy calculator, Sharpe ratio calculator and Max drawdown calculator.
TradingView now calls the Strategy Tester the strategy report, but it is still the panel people search for when a Pine Script backtest looks wrong or does not appear. It runs a strategy through TradingView's broker emulator on chart data and reports simulated orders, never real ones.
Below: what each tab shows, the settings that move the numbers, deep backtesting and plan limits, why the report is empty or missing, and how to check the trade list against Python. Labels and limits come from TradingView's Help Center, the Pine Script v6 User Manual and the plan comparison as of October 2026; the interface changes often.
What does the TradingView Strategy Tester show?
The strategy report shows simulated performance metrics, a list of trades and, for published strategies, the data and settings behind them.
It appears as a tab in the chart's bottom panel whenever a script declared with strategy() is on the chart; on Supercharts you add one through the Indicators button or the / shortcut. The Pine Script v6 User Manual describes three parts (as of October 2026):
| Tab | Contents |
|---|---|
| Metrics | Five sections: Key stats, Return details, Trades analysis, Equity run-ups and drawdowns, Capital efficiency; some tables split results into All, Long and Short |
| Trades | Every simulated trade with its number and type, plus optional columns such as date and time, signal, price, size, return, favorable and adverse excursion, cumulative PnL and duration in bars |
| Properties | Only in published strategy reports: date range, symbol info, strategy inputs and strategy properties |
The Help Center's getting-started article still calls the Trades tab List of trades. Two definitions matter when you compare TradingView with other tools (Help Center, October 2026): the Sharpe ratio uses monthly returns and a default risk-free rate of 2% a year (risk_free_rate in strategy()), and Max drawdown (intrabar) uses each bar's low for longs and high for shorts, so it is usually deeper than a close-to-close drawdown.
Strategy settings that change backtest results
The same Pine code can produce very different reports depending on capital, sizing, costs and fill settings, so set each one explicitly in strategy() and then check the Settings/Properties dialog.
| Property (current label) | strategy() parameter | Documented default | What it changes |
|---|---|---|---|
| Initial capital | initial_capital | 1,000,000 (Help Center; the v6 reference says 100,000) | Buying power; too little means no trades |
| Order size | default_qty_type, default_qty_value | 100% of equity (v6 reference) | Quantity, cash or percent of equity per order |
| Pyramiding | pyramiding | 0 in the v6 reference, 1 in the User Manual: either way one entry per direction, no adding | Same-direction entries strategy.entry() may stack |
| Commission | commission_type, commission_value | None | Percent, cash per contract or per order, on entries and exits |
| Slippage | slippage | 0 ticks | Ticks against you on market and stop orders |
| Margin for long and short positions | margin_long, margin_short | 100, meaning 1:1 leverage | Leverage; a margin call liquidates four times the amount needed to cover the shortfall |
| Limit order execution (older label: Verify price for limit orders) | backtest_fill_limits_assumption | Requested price (0 ticks) | Whether price must trade one tick beyond a limit |
| Order execution delay | process_orders_on_close (the None option) | One tick: an order created at a close fills at the next open | Same-bar or next-bar fills |
| Script execution: On realtime bar tick, On order fill, On history bar tick | calc_on_every_tick, calc_on_order_fills, calc_on_every_history_tick | Off | Extra intrabar calculations; the history option needs Premium or Ultimate |
| Bar detalization: High (older label: Using bar magnifier) | use_bar_magnifier | Off | Lower-timeframe intrabar fills; Premium or Ultimate |
Inputs in the Settings/Properties tab override the strategy() defaults, so if a code change seems ignored, check that tab (Defaults, then Reset settings) or add the strategy to the chart again. The fill rules bar by bar are explained in Pine Script to Python.
Hypothetical cost check. 200 round trips are 400 fills. At 0.1% commission per fill, ending equity is multiplied by 0.999400, about 0.670: a 33% drag against the cost-free default. Two ticks of slippage at a price of 50.00 and a 0.01 tick add 0.04% per fill, and the factor falls to about 0.571, a 43% drag.
Deep backtesting and plan limits (October 2026)
How much history a backtest sees depends on the plan: the chart loads a fixed number of bars, while deep backtesting, on Premium and Ultimate, runs the strategy over a chosen date range of the symbol's available history.
| Feature | Basic | Essential | Plus | Premium | Ultimate |
|---|---|---|---|---|---|
| Historical bars on the chart | 5K | 10K | 10K | 20K | 40K |
| Report metrics | Basic | Advanced | Advanced | Advanced | Advanced |
| Trades as CSV, report as XLSX | No | Yes | Yes | Yes | Yes |
| Deep backtesting, high bar detalization, each history tick execution | No | No | No | Yes | Yes |
| Time limit for calculations | 20 s | 40 s | 40 s | 40 s | 100 s |
What the Help Center says about deep backtesting:
- Starting it: pick a range in the report's Testing period menu; a pink icon marks the mode, and Reset to chart session ends it.
- Limits: as of October 2026, up to two million bars and one million trades per calculation. A longer range runs on its most recent two million bars, and intraday history is shorter than daily history.
- Display: results appear only in the report; chart trades are always calculated without deep backtesting, on less data, so the two can disagree.
- Refresh: after editing the strategy, click Update report; deep results do not recalculate automatically.
Without deep backtesting, the report keeps individual data for the latest 9,000 trades (the Pine limitations page says 9,000 orders, trimming the earliest).
Why is the TradingView Strategy Tester not showing or not working?
Most empty or missing reports have one of a few causes, each with a quick check.
| Symptom | Likely cause | What to do |
|---|---|---|
| No strategy report tab | The script is declared with indicator() or library(), or no strategy is on the chart | Declare it with strategy() and place orders with strategy.entry(), strategy.order() or strategy.exit() |
| Report opens but shows no trades | Conditions never true; capital too small for the full quantity; zero or negative size | Plot conditions with plotshape(); raise capital or lower margin; check sizes |
| Red exclamation mark beside the script | A runtime error stopped the calculation | Click it, read the message and fix the cause |
| Fewer trades than expected, or results drift over time | Chart history is capped by plan, and the first loaded bar moves forward | Use deep backtesting or export results regularly |
| Code changes have no effect | Settings/Properties values override code defaults; deep results not refreshed | Reset settings or re-add the strategy; click Update report |
| A second strategy does not run | The Help Center says only one strategy can run on a chart at a time | Use another chart or layout |
| Calculation stops with a time-out error | The plan's calculation time limit | Simplify loops or request less data |
Also avoid Heikin Ashi, Renko and other non-standard charts, which the Pine Script FAQ calls unsuitable for backtesting. TradingView's report documentation describes Supercharts and does not cover the mobile apps, so review the full report and exports on the web or desktop version.
How to export the trade list and compare it with a Python backtest
Download the trade list as CSV from the Trades tab, or the whole report as XLSX from its menu, then compare trades one by one with your own backtest instead of comparing net profit.
According to the Pine Script manual, the Download icon on the Trades tab saves all available trade data as a CSV file, and the report's context menu offers Download data as XLSX, which also includes the Properties data; both exports need Essential or higher as of 25 October 2026. Column names depend on the interface version and account currency, so map them once to entry time, entry price, exit time and exit price, and convert both sides to the same time zone. This function lists every trade that differs:
import pandas as pd
def compare_trades(tv: pd.DataFrame, py: pd.DataFrame, tick: float) -> pd.DataFrame:
"""Both frames: entry_time, entry_price, exit_time, exit_price (same time zone)."""
m = tv.merge(py, on="entry_time", how="outer", suffixes=("_tv", "_py"), indicator=True)
m["entry_ticks"] = ((m.entry_price_tv - m.entry_price_py) / tick).round(1)
m["exit_ticks"] = ((m.exit_price_tv - m.exit_price_py) / tick).round(1)
ok = (m._merge == "both") & (m.exit_time_tv == m.exit_time_py) \
& (m.entry_ticks.abs() <= 0.5) & (m.exit_ticks.abs() <= 0.5)
return m.loc[~ok, ["entry_time", "_merge", "exit_time_tv", "exit_time_py", "exit_ticks"]]
t = pd.to_datetime # hypothetical trades
tv = pd.DataFrame({"entry_time": t(["2026-03-02", "2026-04-13", "2026-06-01"]),
"entry_price": [101.25, 98.40, 104.10],
"exit_time": t(["2026-03-20", "2026-05-04", "2026-06-22"]),
"exit_price": [106.80, 97.15, 103.55]})
py = tv.copy()
py.loc[1, ["exit_time", "exit_price"]] = [t("2026-05-05"), 96.90] # one bar later
print(compare_trades(tv, py, tick=0.01).to_string(index=False))Output:
entry_time _merge exit_time_tv exit_time_py exit_ticks
2026-04-13 both 2026-05-04 2026-05-05 25.0A trade that exits one bar later usually points to a different fill rule, such as the execution delay or an intrabar stop, not different logic. Match trades first and metrics second, since TradingView's monthly Sharpe ratio and intrabar drawdown differ from most Python libraries' definitions. Libraries for the Python side are compared in backtesting Python libraries.
From the strategy report to alerts and live trading
A strategy report is a simulation; live orders need alerts, a webhook bridge and an independent check of the results.
Strategy alerts fire only for orders the emulator fills in real time, never for historical trades, and an alert keeps a copy of the strategy and its settings from the moment it was created, so recreate it after every change. When alerts misbehave, work through TradingView alerts not working; forwarding fills to an exchange is covered in TradingView webhook bot.
A good report is not evidence of a future edge. Simulated results leave out real-world factors, past results do not guarantee future performance, and a strategy tuned on the chart's history carries the biases described in backtesting pitfalls. Automated trading can lose money. Porting, verifying and automating Pine strategies is the scope of the TradingView automation service.
Frequently asked questions
Is the TradingView Strategy Tester free?
Yes, with basic metrics on the free Basic plan. As of 25 October 2026, advanced metrics and exports need Essential or higher, and deep backtesting needs Premium or Ultimate.
Where is the Strategy Tester tab in TradingView?
It is a tab below the chart, now called the strategy report, and it appears only while a strategy is on the chart.
Why does my TradingView strategy show no trades?
Usually the entry conditions are never true, the initial capital cannot buy the full order quantity, or a runtime error stopped the script. Scripts declared with indicator() never produce a strategy report.
Why are deep backtesting results different from the chart?
Chart trades use only the bars loaded on the chart, while deep backtesting uses up to two million bars of history (October 2026), so positions start elsewhere.
How many trades does the Strategy Tester keep?
As of October 2026 it keeps data for the latest 9,000 trades in the default range, and every trade, up to one million, with deep backtesting.
Sources
- TradingView Help Center: TradingView Strategy Report: How to start (opens in a new tab)
- TradingView Pine Script v6 User Manual: Strategies (strategy report, properties, margin calls, exports) (opens in a new tab)
- TradingView Pine Script v6 Reference Manual: strategy() (parameter defaults) (opens in a new tab)
- TradingView Help Center: Strategy properties (opens in a new tab)
- TradingView Help Center: Initial capital (opens in a new tab)
- TradingView Help Center: How Deep Backtesting works (opens in a new tab)
- TradingView Help Center: How much data is available for Deep Backtesting? (opens in a new tab)
- TradingView Help Center: Why are the results of Deep Backtesting not shown on the chart? (opens in a new tab)
- TradingView Help Center: I have added a strategy to my chart, but it does not generate orders (opens in a new tab)
- TradingView Pine Script v6 FAQ: Strategies (opens in a new tab)
- TradingView Pine Script v6 User Manual: Limitations (chart bars, 9,000 orders) (opens in a new tab)
- TradingView: Plans and pricing (strategy backtesting comparison) (opens in a new tab)
- TradingView Help Center: Sharpe ratio (opens in a new tab)
- TradingView Help Center: Max drawdown (intrabar) (opens in a new tab)
- TradingView Help Center: Strategy alerts (opens in a new tab)
This guide is general information about software and markets, not investment, legal or tax advice. Automated trading can lose money, past or backtested performance does not guarantee future results, and the rules that apply depend on your jurisdiction and your exchange's terms. Sources, checks and corrections: see the editorial policy.