TradingView Pine Script Strategies: What is the Complete Guide?

Pine Script on TradingView has become the go-to language for technical traders and developers looking to automate their analysis and trading ideas. Moving beyond simple indicators, crafting a robust trading strategy requires a deeper understanding of Pine Script’s execution model, functions, and best practices.

This guide aims to provide a comprehensive overview for intermediate to advanced users looking to build, test, and refine their trading strategies directly within the TradingView platform.

Introduction to Pine Script Strategies

What are TradingView Strategies?

A TradingView strategy is a Pine Script program that defines specific rules for entering and exiting trades based on technical conditions. Unlike indicators, which only plot data or signals on a chart, strategies execute hypothetical trades according to these rules, tracking performance metrics like profit, drawdown, and win rate.

They provide a powerful way to backtest a trading idea against historical data, offering quantitative evidence of its potential effectiveness before risking capital.

Key Differences Between Strategies and Indicators

While both indicators and strategies are written in Pine Script, their purpose and execution differ significantly.

• Purpose: Indicators visualize data or potential signals; strategies simulate trading actions (entries, exits).
• Execution: Indicators run on each bar and plot values; strategies run on each bar, evaluate entry/exit conditions, and execute hypothetical trades.
• Output: Indicators produce lines, shapes, or values on the chart or in panes; strategies produce performance metrics, trade lists, and equity curves in the Strategy Tester tab.
• Functions: Strategies use dedicated functions like strategy.entry(), strategy.exit(), and strategy.close() to manage trades, which are not available to indicators.

Understanding this distinction is crucial. An indicator might show a bullish crossover, but only a strategy can simulate buying at that moment and later selling based on different conditions.

Benefits of Using Pine Script for Strategy Development

Developing strategies in Pine Script offers several key advantages:

• Integration: Seamless integration with TradingView’s charting platform and vast historical data.
• Accessibility: Relatively simple syntax compared to general-purpose programming languages.
• Backtesting Engine: Built-in, robust backtesting capabilities with detailed performance reports.
• Community: Large and active community for support, shared ideas, and learning.
• Automation Potential: Strategies can trigger alerts, and with brokers supporting TradingView integration, potentially automate execution.

Leveraging these benefits allows traders to rapidly prototype, test, and iterate on trading ideas in a quantitative manner.

Building Your First Pine Script Strategy: A Step-by-Step Guide

Let’s walk through the fundamental steps of creating a simple strategy.

Setting Up Your TradingView Chart and Pine Editor

Open any chart on TradingView. At the bottom of the screen, you’ll find the Pine Editor. Click on it to open the editor pane. You can select Open -> New blank strategy to start with a basic template.

The editor is where you’ll write your code. The console below helps with debugging.

Basic Strategy Structure: strategy() function

Every strategy must begin with the strategy() function. This function declares the script as a strategy and sets key properties like the strategy’s name, initial capital, commission, and slippage settings.

//@version=5
strategy("My First Strategy", shorttitle="MFS", overlay=true,
     initial_capital=10000, commission=0.0, slippage=0)

// Your strategy logic goes here

• @version: Specifies the Pine Script version. Always use the latest.
• strategy(): The core declaration function.
  • name: Full name for the strategy.
  • shorttitle: Abbreviated name.
  • overlay: Set to true to plot on the price chart, false to plot in a separate pane.
  • initial_capital: Starting equity for backtesting.
  • commission: Per-trade commission rate (e.g., 0.01 for 0.01%).
  • slippage: Simulated slippage per order in ticks.

These parameters are crucial for realistic backtesting results.

Defining Inputs: Strategy Settings and User Customization

Inputs allow users to easily change strategy parameters without editing the code. Use the input.* functions.

//@version=5
strategy("Simple MA Crossover", shorttitle="MAC", overlay=true,
     initial_capital=10000, commission=0.0, slippage=0)

// Define inputs
fast_len = input.int(title="Fast MA Length", defval=10)
slow_len = input.int(title="Slow MA Length", defval=30)

// Calculate moving averages
fast_ma = ta.sma(close, fast_len)
slow_ma = ta.sma(close, slow_len)

// Your strategy logic will use fast_ma and slow_ma

Inputs make your strategy flexible and enable optimization via the Strategy Tester’s settings.

Generating Buy and Sell Signals: strategy.entry() and strategy.close()

These functions are the heart of your strategy’s trading logic.

• strategy.entry(id, direction, qty, limit, stop, oca_group, comment, when): Enters a position. id is a unique string name for the order. direction is strategy.long or strategy.short. qty is the number of units/contracts. Optional parameters like limit, stop define order types.
• strategy.close(id, comment, when): Closes an open position identified by id. This is typically used to exit a trade initiated by strategy.entry with the same id.
• strategy.order(id, direction, qty, limit, stop, oca_group, comment, when): A more general function that can enter or exit trades. direction specifies if it’s a strategy.buy or strategy.sell order.

Here’s a simple moving average crossover strategy using these functions:

//@version=5
strategy("MA Crossover Entry/Close", shorttitle="MAC_EC", overlay=true,
     initial_capital=10000, commission=0.0, slippage=0)

// Define inputs
fast_len = input.int(title="Fast MA Length", defval=10)
slow_len = input.int(title="Slow MA Length", defval=30)

// Calculate moving averages
fast_ma = ta.sma(close, fast_len)
slow_ma = ta.sma(close, slow_len)

// Define signals
buy_signal = ta.crossover(fast_ma, slow_ma)
sell_signal = ta.crossunder(fast_ma, slow_ma)

// Execute trades
strategy.entry("Buy", strategy.long, when = buy_signal)
strategy.close("Buy", when = sell_signal) // Close the "Buy" trade on sell_signal

// Optional: Implement short side
strategy.entry("Sell", strategy.short, when = sell_signal)
strategy.close("Sell", when = buy_signal) // Close the "Sell" trade on buy_signal

// Plot MAs (optional)
plot(fast_ma, color=color.blue)
plot(slow_ma, color=color.red)

• The when argument is crucial; the order is placed only when the condition is true on the current bar.
• Using separate id strings (“Buy”, “Sell”) allows managing long and short positions independently.

Advanced Strategy Development Techniques

Moving beyond simple entries, effective strategies require sophisticated exit logic and adaptation to market conditions.

Implementing Stop-Loss and Take-Profit Orders

Hard stops and profit targets are essential risk management tools. strategy.entry and strategy.exit allow setting these directly.

//@version=5
strategy("MA Crossover with SL/TP", shorttitle="MAC_SLTP", overlay=true,
     initial_capital=10000, commission=0.0, slippage=0,
     pyramiding=0, max_entries_per_trade=1)

// Inputs
fast_len = input.int(title="Fast MA Length", defval=10)
slow_len = input.int(title="Slow MA Length", defval=30)
stop_loss_percent = input.float(title="Stop Loss Percent", defval=2.0) / 100
take_profit_percent = input.float(title="Take Profit Percent", defval=4.0) / 100

// Calculations
fast_ma = ta.sma(close, fast_len)
slow_ma = ta.sma(close, slow_len)

// Signals
buy_signal = ta.crossover(fast_ma, slow_ma)
sell_signal = ta.crossunder(fast_ma, slow_ma)

// Calculate SL/TP levels for the current potential entry
long_stop_level = close * (1 - stop_loss_percent)
long_profit_level = close * (1 + take_profit_percent)

short_stop_level = close * (1 + stop_loss_percent)
short_profit_level = close * (1 - take_profit_percent)

// Execute trades with SL/TP
// Use strategy.order for simplicity when immediately defining exit levels upon entry
if buy_signal
    strategy.order("BuyOrder", strategy.long, 1, comment="Enter Long")
    // Set SL/TP on the SAME bar as entry. Requires position to be open on this bar.
    // Check strategy.position_size > 0 for robustness if entry might be delayed.
    strategy.exit("Exit Buy", from_entry="BuyOrder", stop=long_stop_level, limit=long_profit_level)

if sell_signal
    strategy.order("SellOrder", strategy.short, 1, comment="Enter Short")
    strategy.exit("Exit Sell", from_entry="SellOrder", stop=short_stop_level, limit=short_profit_level)

// Note: The SL/TP calculation here is basic. A more advanced approach would calculate levels based on the actual entry price.
// Also, strategy.exit with from_entry requires the entry order with that ID to have filled.

• stop: Sets a stop-loss price.
• limit: Sets a take-profit price.
• from_entry: Links the exit order to a specific entry order ID. This is best practice.

These orders are automatically managed by the strategy engine once the entry order is filled.

Using Trailing Stop-Loss Orders

Trailing stops allow locking in profits as the market moves favorably. This is also handled by strategy.exit.

//@version=5
strategy("Trailing Stop Example", shorttitle="TrailStop", overlay=true,
     initial_capital=10000, commission=0.0, slippage=0)

// Inputs
entry_condition = ta.crossover(ta.sma(close, 10), ta.sma(close, 30)) // Example condition
trail_points = input.float(title="Trailing Stop Points (Ticks)", defval=50.0)

// Example entry
strategy.entry("LongEntry", strategy.long, 1, when=entry_condition)

// Implement trailing stop
// The trail_points argument expects price units, not ticks.
// If you want ticks, you need to convert: trail_price = trail_points * syminfo.mintick
trail_price = input.float(title="Trailing Stop Price", defval=0.5) // Example: 0.5 price units

strategy.exit("TrailingExit", from_entry="LongEntry", trail_points=trail_price)

• trail_points: Activates a trailing stop. The value is the distance from the highest/lowest price achieved after entry.

TradingView’s trailing stop follows the price and triggers when the price moves against the position by the specified trail_points distance from the peak (for long) or trough (for short) since the entry.

Integrating Multiple Indicators for Confluence

Combining signals from different indicators is a common practice to improve strategy robustness.

//@version=5
strategy("Multi-Indicator Strategy", shorttitle="Multi", overlay=true,
     initial_capital=10000, commission=0.0)

// Inputs
ma_len = input.int(title="MA Length", defval=20)
rsi_len = input.int(title="RSI Length", defval=14)
rsi_ob = input.int(title="RSI Overbought", defval=70)
rsi_os = input.int(title="RSI Oversold", defval=30)

// Calculations
ma = ta.sma(close, ma_len)
rsi = ta.rsi(close, rsi_len)

// Signals: Combine MA trend filter with RSI signals
buy_condition = close > ma and rsi < rsi_os // Price above MA AND RSI oversold
sell_condition = close < ma and rsi > rsi_ob // Price below MA AND RSI overbought

// Execute trades
strategy.entry("Buy", strategy.long, when=buy_condition)
strategy.close("Buy", when=sell_condition)

strategy.entry("Sell", strategy.short, when=sell_condition)
strategy.close("Sell", when=buy_condition)

// Plots (optional)
plot(ma, color=color.blue, title="MA")
plot(rsi, color=color.purple, title="RSI", display=display.pane)

This example shows how to use logical operators (and, or) to combine boolean signals from different indicator calculations to define entry and exit conditions.

Coding for Different Market Conditions (Trend vs. Range)

A strategy effective in a trending market might fail in a ranging market, and vice-versa. You can use Pine Script to identify the market regime and apply different rules.

A common approach is to use indicators like ADX or volatility measures (like Average True Range) to gauge market strength or Chop Index to identify choppiness.

//@version=5
strategy("Trend-Range Adaptive", shorttitle="Adaptive", overlay=true,
     initial_capital=10000, commission=0.0)

// Inputs
adx_len = input.int(title="ADX Length", defval=14)
adx_threshold = input.float(title="ADX Trend Threshold", defval=25.0)

// Calculate ADX
adx = ta.adx(close, adx_len)

// Identify market regime
istrending = adx > adx_threshold
isranging = not istranding

// Example: Use different MA lengths based on regime
fast_len = istranding ? 10 : 20 // Shorter MA in trend, longer in range
slow_len = istranding ? 20 : 50

fast_ma = ta.sma(close, fast_len)
slow_ma = ta.sma(close, slow_len)

// Simple MA crossover based on regime-adapted MAs
buy_condition = ta.crossover(fast_ma, slow_ma)
sell_condition = ta.crossunder(fast_ma, slow_ma)

// Execute trades (using the adapted signals)
strategy.entry("Buy", strategy.long, when = buy_condition)
strategy.close("Buy", when = sell_condition)

strategy.entry("Sell", strategy.short, when = sell_condition)
strategy.close("Sell", when = buy_condition)

// Plot ADX (optional)
plot(adx, color=color.orange, title="ADX", display=display.pane)

This example uses the ternary operator (? :) to select MA lengths based on whether ADX indicates a trending or ranging market. More complex logic could involve enabling/disabling entirely different entry/exit rules based on the market regime variable.

Backtesting and Optimization

Backtesting is where you evaluate your strategy’s historical performance. Optimization helps find potentially better parameters, but must be done carefully.

Understanding Backtesting Results: Key Metrics (Profit Factor, Drawdown, Win Rate)

After adding your strategy to the chart and running the Strategy Tester, you’ll see a performance summary. Key metrics include:

• Net Profit: Total profit minus total loss.
• Profit Factor: Gross Profit / Gross Loss. A value > 1 indicates profitability.
• Maximum Drawdown: The largest peak-to-trough decline in equity. Indicates risk.
• Total Closed Trades: Number of completed trades.
• Percent Profitable (Win Rate): (Number of profitable trades / Total trades) * 100.
• Average Trade: Net Profit / Total Closed Trades.

Analyzing these metrics together gives a holistic view of performance, risk, and consistency.

Optimizing Strategy Parameters Using the Strategy Tester

The Strategy Tester has an “Optimizer” tab (often looks like a trophy). You can select input parameters you defined with input.* and set ranges for optimization. TradingView will test combinations within those ranges.

• Careful Selection: Only optimize parameters you have a strong reason to believe are sensitive and impactful.
• Range Definition: Set realistic ranges for the parameters.
• Evaluation Criteria: Choose whether to optimize for Net Profit, Profit Factor, Drawdown, etc.

Optimization can reveal parameter values that performed best historically, but this leads to the risk of overfitting.

Walkforward Analysis: Avoiding Overfitting

Overfitting occurs when a strategy performs exceptionally well on the historical data it was optimized on, but poorly on new, unseen data. This happens when the strategy is curve-fitted to noise rather than true market dynamics.

Walkforward analysis is a technique to combat this. Instead of optimizing on the entire historical dataset, you:

1. Define an ‘in-sample’ period for optimization (e.g., 1 year).
2. Optimize parameters on the in-sample data.
3. Test the optimized parameters on a subsequent ‘out-of-sample’ period (e.g., 3 months) without further optimization.
4. Shift both windows forward and repeat.

A strategy is considered robust if it performs acceptably across multiple out-of-sample periods. Pine Script doesn’t have built-in walkforward tools, but you can simulate it manually by changing the backtesting date range and inputs.

Limitations of Backtesting and Real-World Considerations

Backtesting is based on historical data and assumptions. It has limitations:

• Assumptions: Assumes fills at historical prices (Open, High, Low, Close) which may not happen in reality, especially with limit/stop orders or low liquidity.
• Slippage & Commission: While configurable, exact real-world costs are hard to model perfectly.
• Lookahead Bias: Using future data unintentionally (e.g., calculating an indicator based on the close of the current bar for a signal on that bar’s open) is a major pitfall.
• Regime Change: Market dynamics change; a strategy optimized on past data may not work in the future.
• Psychology: Backtesting doesn’t account for the psychological stress of live trading.

Always treat backtesting results as an estimate, not a guarantee of future performance.

Advanced Pine Script Strategy Features

Pine Script offers advanced features for more complex strategy design and execution management.

Using strategy.exit() for Advanced Exit Strategies

We touched on strategy.exit for SL/TP. It’s also used for more complex exits, like partial closes or exiting multiple entries with one command.

//@version=5
strategy("Advanced Exit Example", shorttitle="AdvExit", overlay=true,
     initial_capital=10000, commission=0.0,
     pyramiding=2, max_entries_per_trade=10) // Example allowing pyramiding

// Inputs
entry_signal = ta.crossover(ta.sma(close, 15), ta.sma(close, 45))
exit_signal_partial = ta.crossunder(ta.sma(close, 15), ta.sma(close, 45)) // Primary exit
exit_signal_final = close < ta.sma(close, 100) // Trailing longer-term exit

// Example: Multiple entries
strategy.entry("MA_Entry", strategy.long, 1, when=entry_signal)
strategy.entry("MA_Entry", strategy.long, 1, when=entry_signal[1] and not entry_signal) // Example: Second entry if condition true for 2nd bar

// Partial close on primary exit signal
// Close 50% of the total position size linked to "MA_Entry"
strategy.exit("Partial Exit", from_entry="MA_Entry", qty_percent=50, when=exit_signal_partial)

// Close remaining position on final exit signal, also setting a wide safety stop
strategy.exit("Final Exit", from_entry="MA_Entry", stop=strategy.position_avg_price * 0.8, when=exit_signal_final)

// Or use limit/stop with from_entry and link to specific entry IDs
// strategy.exit("Exit1", from_entry="BuyEntry1", limit=..., stop=...)
// strategy.exit("Exit2", from_entry="BuyEntry2", limit=..., stop=...)

• qty: Specifies the quantity to exit.
• qty_percent: Specifies the percentage of the current position to exit.
• from_entry: Exits positions entered with the specified id. If used with pyramiding, it exits the total position size opened with that id up to that point.
• If from_entry is omitted, strategy.exit applies to the entire open position (sum of all entries).

strategy.exit is powerful for managing complex exit logic, including scaling out of positions.

Working with Timeframes and Aggregation

Strategies often benefit from looking at data from different timeframes (e.g., entry on 15m based on daily trend).

Use the request.security() function to fetch data from other symbols or timeframes.

//@version=5
strategy("Multi-Timeframe Strategy", shorttitle="MTF Strat", overlay=true,
     initial_capital=10000, commission=0.0)

// Inputs
short_tf = input.timeframe(title="Entry Timeframe", defval="15")
long_tf = input.timeframe(title="Trend Timeframe", defval="D")
ma_len = input.int(title="Trend MA Length", defval=50)

// Get MA from the longer timeframe
// Use close[1] on the higher timeframe to avoid lookahead bias
[high_tf_close] = request.security(syminfo.tickerid, long_tf, [close], lookahead=barmerge.lookahead_on)
high_tf_ma = ta.sma(high_tf_close, ma_len)

// Determine trend based on longer timeframe MA (avoiding lookahead by checking previous bar's MA)
long_term_trend_up = close > high_tf_ma // Compare current bar close to previous higher TF MA

// Example: Simple entry condition on the short timeframe, filtered by long timeframe trend
short_tf_signal = ta.crossover(ta.sma(close, 10), ta.sma(close, 20))

// Execute trade only if short TF signal AND long TF trend is up
strategy.entry("Buy", strategy.long, when = short_tf_signal and long_term_trend_up)
strategy.close("Buy", when = ta.crossunder(ta.sma(close, 10), ta.sma(close, 20)))

// Plot higher timeframe MA (optional)
plot(high_tf_ma, color=color.orange, title="Higher TF MA")

• request.security(): Fetches data (source, timeframe, expression, lookahead).
• syminfo.tickerid: Gets the current symbol ID.
• lookahead=barmerge.lookahead_on: Necessary for strategies to get the closed value of the higher timeframe bar when the current bar is processing.
• Crucially, use close (current bar on current TF) vs high_tf_ma (previous bar on higher TF) or similar logic to prevent lookahead bias when combining timeframes.

Alerts and Notifications: Automating Your Trading

Pine Script strategies can trigger alerts, which can be used to send notifications or execute orders via third-party tools that integrate with TradingView’s webhook system.

Use the alert() function.

//@version=5
strategy("Alert Example Strategy", shorttitle="Alert Strat", overlay=true,
     initial_capital=10000, commission=0.0)

// ... (Strategy logic calculating buy_signal and sell_signal) ...

buy_signal = ta.crossover(ta.sma(close, 10), ta.sma(close, 30))
sell_signal = ta.crossunder(ta.sma(close, 10), ta.sma(close, 30))

// Execute trades (optional, strategy doesn't need trades to generate alerts)
strategy.entry("Buy", strategy.long, when=buy_signal)
strategy.close("Buy", when=sell_signal)

// Generate alerts when signals occur
if buy_signal
    alert("Strategy BUY Signal for " + syminfo.ticker, alert.freq_once_per_bar_close)

if sell_signal
    alert("Strategy SELL Signal for " + syminfo.ticker, alert.freq_once_per_bar_close)

// To alert on strategy orders being filled:
// alert(strategy.order.alert_message, alert.freq_once_per_bar)

• alert(message, freq): Triggers an alert with the specified message and frequency.
• strategy.order.alert_message: A built-in variable that contains a formatted message about executed strategy orders.

After adding the strategy to the chart, go to the Alert icon (clock) and set up a new alert, selecting your strategy as the condition.

Debugging and Troubleshooting Common Errors

Even experienced developers encounter errors. Common issues include:

• Compilation Errors: Syntax errors. The Pine Editor console provides line numbers and descriptions.
• Runtime Errors: Errors that occur during execution (e.g., division by zero, accessing out-of-bounds history). Check the Strategy Tester’s log tab.
• Logical Errors: The code runs, but the strategy doesn’t trade as expected. This is the hardest to find.
  • Use plot() to visualize intermediate calculations and signals.
  • Use log.info() or plotchar() to print variable values or messages to the console/chart on specific bars.
  • Check the when conditions carefully in strategy.entry/exit.
  • Verify id strings match between strategy.entry and strategy.close/exit.
  • Ensure you understand Pine Script’s execution model (scripts run on each bar, evaluating code from top to bottom).
  • Be mindful of lookahead bias, especially with request.security or using non-close prices for signals evaluated on the same bar.

Developing a systematic debugging approach will save significant time. Start by isolating the part of the code causing unexpected behavior and add plots or logs to inspect values at that point.

Mastering Pine Script strategy development is an ongoing process. By understanding the core functions, applying robust backtesting techniques, and leveraging advanced features while being mindful of the limitations, you can build powerful and effective trading algorithms.