Pine Script: How to Implement Long and Short Strategies?

25.07.2025
1026

28 min
944

Implementing robust trading strategies is a cornerstone of systematic trading. Pine Script, TradingView’s proprietary scripting language, offers a powerful yet accessible environment for developing, backtesting, and deploying both long and short trading strategies. This article delves into the practical aspects of constructing these strategies, from basic implementations to more advanced considerations.

Understanding Long and Short Positions

A long position is initiated with the expectation that an asset’s price will rise. Traders buy an asset with the intention of selling it later at a higher price. Conversely, a short position is taken when a trader anticipates an asset’s price will fall. This involves borrowing an asset, selling it on the open market, and then buying it back at a lower price to return to the lender, pocketing the difference (minus fees).

Successfully implementing both types of positions allows traders to potentially profit from market movements in either direction, providing greater flexibility and opportunity.

Why Use Pine Script for Strategy Implementation?

Pine Script is specifically designed for creating trading tools on TradingView. Its key advantages for strategy implementation include:

Integrated Backtesting Engine: Allows for rapid testing of strategy ideas on historical data directly within the TradingView platform.
Vast Indicator Library: Provides access to hundreds of built-in indicators and a large community-contributed library, which can be easily incorporated into strategies.
Real-time Data and Chart Integration: Strategies run directly on TradingView charts, reacting to live market data.
Alert System: Facilitates notifications for trade signals, which can be used for discretionary trading or triggering automated systems via webhooks.
Simplified Syntax: While powerful, Pine Script’s syntax is generally easier to grasp for traders compared to general-purpose programming languages like Python for similar tasks initially.

Setting up TradingView and Pine Editor

Access TradingView: Navigate to the TradingView website and open a chart for any instrument.
Open Pine Editor: At the bottom of the chart, click on the “Pine Editor” tab.
Create a New Script: In the Pine Editor, click “Open” and select “New blank strategy”. This provides a basic template to start building your strategy.

Ensure you are familiar with the basics of the Pine Editor interface, including compiling scripts (Add to Chart) and accessing the Strategy Tester for backtesting results.

Implementing a Basic Long Strategy

A long strategy aims to profit from upward price movements. We’ll define entry conditions, implement them in Pine Script, and add risk management components.

Defining Entry Conditions for Long Positions

For our basic long strategy, let’s consider a simple moving average (SMA) crossover combined with a Relative Strength Index (RSI) condition:

Entry Condition 1: The closing price crosses above the 50-period SMA.
Entry Condition 2: The 14-period RSI is above 50 (indicating bullish momentum).

Both conditions must be met for a long entry signal.

Writing the Pine Script Code for Long Entry

//@version=5
strategy("Basic Long Strategy", overlay=true, initial_capital=10000, default_qty_value=10, default_qty_type=strategy.percent_of_equity)

// Inputs
lenSMA = input.int(50, title="SMA Length")
lenRSI = input.int(14, title="RSI Length")
rsiThreshold = input.float(50, title="RSI Threshold")

// Indicators
smaValue = ta.sma(close, lenSMA)
rsiValue = ta.rsi(close, lenRSI)

// Entry Conditions
longCondition = ta.crossunder(close, smaValue) and rsiValue > rsiThreshold

// Plot SMA for visualization
plot(smaValue, color=color.blue, title="SMA")

// Strategy Logic
if (longCondition)
    strategy.entry("Long", strategy.long)

In this script:

strategy() declares it as a strategy script, sets overlay to true, initial capital, and default trade quantity.
input.int() and input.float() create user-configurable inputs.
ta.sma() and ta.rsi() calculate the respective indicator values.
longCondition combines our defined entry rules.
strategy.entry("Long", strategy.long) executes a long entry when longCondition is true. The first argument is the trade ID, and the second specifies the direction.

Adding Stop Loss and Take Profit for Long Trades

Effective risk management is crucial. We can add stop-loss (SL) and take-profit (TP) levels using strategy.exit().

//@version=5
strategy("Long Strategy with SL/TP", overlay=true, initial_capital=10000, default_qty_value=1, default_qty_type=strategy.fixed)

// Inputs
lenSMA = input.int(50, title="SMA Length")
lenRSI = input.int(14, title="RSI Length")
rsiThreshold = input.float(50, title="RSI Threshold")
stopLossPoints = input.int(100, title="Stop Loss (Points)", minval=1)
takeProfitPoints = input.int(200, title="Take Profit (Points)", minval=1)

// Indicators
smaValue = ta.sma(close, lenSMA)
rsiValue = ta.rsi(close, lenRSI)

// Entry Conditions
longCondition = ta.crossunder(close, smaValue) and rsiValue > rsiThreshold

// Plot SMA
plot(smaValue, color=color.blue, title="SMA")

// Strategy Logic
if (longCondition and strategy.opentrades == 0) // Ensure no open trades before entering
    strategy.entry("Long", strategy.long)

// Exit Logic for Long Trade
if (strategy.position_size > 0) // If we are in a long position
    strategy.exit("Exit Long", from_entry="Long", loss=stopLossPoints, profit=takeProfitPoints)

Key additions:

stopLossPoints and takeProfitPoints define SL/TP levels in price points (ticks for futures, pips for forex). Note: For percentage-based or ATR-based SL/TP, calculations involving strategy.position_avg_price and ta.atr() would be needed.
strategy.exit("Exit Long", from_entry="Long", loss=stopLossPoints, profit=takeProfitPoints): This function places exit orders. from_entry="Long" links it to our entry named “Long”. loss specifies the stop-loss distance in points, and profit specifies the take-profit distance in points from the entry price.
We’ve added strategy.opentrades == 0 to the entry condition to prevent multiple entries while a trade is already open. Alternatively, strategy.position_size == 0 achieves a similar goal.

Backtesting the Long Strategy

Once the script is added to the chart:

Open the Strategy Tester tab.
Review the Overview: Net Profit, Max Drawdown, Profit Factor, etc.
Analyze the Performance Summary and List of Trades for detailed insights.
Adjust input parameters (SMA Length, RSI Threshold, SL/TP points) in the script’s settings (gear icon on the script title) to observe their impact on performance.

Remember that backtest results are historical and not guarantees of future performance. Pay attention to the number of trades; too few trades might indicate insufficient data or an overly selective strategy.

Implementing a Basic Short Strategy

A short strategy aims to profit from downward price movements. The structure is analogous to the long strategy, but with inverted conditions.

Defining Entry Conditions for Short Positions

For our basic short strategy, let’s use inverse conditions to our long example:

Entry Condition 1: The closing price crosses below the 50-period SMA.
Entry Condition 2: The 14-period RSI is below 50 (indicating bearish momentum).

Writing the Pine Script Code for Short Entry

//@version=5
strategy("Basic Short Strategy", overlay=true, initial_capital=10000, default_qty_value=10, default_qty_type=strategy.percent_of_equity)

// Inputs
lenSMA = input.int(50, title="SMA Length")
lenRSI = input.int(14, title="RSI Length")
rsiThreshold = input.float(50, title="RSI Threshold")

// Indicators
smaValue = ta.sma(close, lenSMA)
rsiValue = ta.rsi(close, lenRSI)

// Entry Conditions
shortCondition = ta.crossunder(close, smaValue) and rsiValue < rsiThreshold

// Plot SMA
plot(smaValue, color=color.red, title="SMA")

// Strategy Logic
if (shortCondition)
    strategy.entry("Short", strategy.short)

Key differences:

shortCondition: ta.crossunder(close, smaValue) and rsiValue < rsiThreshold.
strategy.entry("Short", strategy.short): Executes a short entry.

Adding Stop Loss and Take Profit for Short Trades

Risk management for short trades is equally important.

//@version=5
strategy("Short Strategy with SL/TP", overlay=true, initial_capital=10000, default_qty_value=1, default_qty_type=strategy.fixed)

// Inputs
lenSMA = input.int(50, title="SMA Length")
lenRSI = input.int(14, title="RSI Length")
rsiThreshold = input.float(50, title="RSI Threshold")
stopLossPoints = input.int(100, title="Stop Loss (Points)", minval=1)
takeProfitPoints = input.int(200, title="Take Profit (Points)", minval=1)

// Indicators
smaValue = ta.sma(close, lenSMA)
rsiValue = ta.rsi(close, lenRSI)

// Entry Conditions
shortCondition = ta.crossunder(close, smaValue) and rsiValue < rsiThreshold

// Plot SMA
plot(smaValue, color=color.red, title="SMA")

// Strategy Logic
if (shortCondition and strategy.opentrades == 0)
    strategy.entry("Short", strategy.short)

// Exit Logic for Short Trade
if (strategy.position_size < 0) // If we are in a short position
    strategy.exit("Exit Short", from_entry="Short", loss=stopLossPoints, profit=takeProfitPoints)

Key adjustments for short exits:

strategy.position_size < 0 checks if a short position is active.
strategy.exit("Exit Short", from_entry="Short", ...) is used. The loss and profit parameters still define points from entry, but Pine Script correctly calculates the price levels for a short trade (stop-loss above entry, take-profit below entry).

Backtesting the Short Strategy

The backtesting process is identical to the long strategy. Use the Strategy Tester to evaluate performance metrics specifically for the short conditions. Analyze how parameter changes affect the outcomes. Consider markets or timeframes where bearish trends are more prevalent for testing short strategies.

Combining Long and Short Strategies

Many traders develop strategies that can take both long and short positions, adapting to changing market conditions. This allows for continuous market participation if desired.

Creating a Strategy That Takes Both Long and Short Positions

We can merge the logic from our previous examples into a single script. The key is to manage entries and exits so the strategy doesn’t attempt to be long and short simultaneously, or to define if it’s a reversing strategy or one that closes a position before opening an opposite one.

//@version=5
strategy("Combined Long/Short Strategy", overlay=true, initial_capital=10000, default_qty_value=1, default_qty_type=strategy.fixed, pyramiding=0)

// Inputs
lenSMA = input.int(50, title="SMA Length")
lenRSI = input.int(14, title="RSI Length")
rsiLongThreshold = input.float(55, title="RSI Long Threshold")
rsiShortThreshold = input.float(45, title="RSI Short Threshold")
stopLossPoints = input.int(150, title="Stop Loss (Points)", minval=1)
takeProfitPoints = input.int(300, title="Take Profit (Points)", minval=1)

// Indicators
smaValue = ta.sma(close, lenSMA)
rsiValue = ta.rsi(close, lenRSI)

// Entry Conditions
longEntryCondition = ta.crossunder(close, smaValue) and rsiValue > rsiLongThreshold
shortEntryCondition = ta.crossunder(close, smaValue) and rsiValue < rsiShortThreshold

// Plot SMA
plot(smaValue, color=color.orange, title="SMA")

// Strategy Logic
// Manage Long Trades
if (longEntryCondition and strategy.position_size == 0) // Only enter if flat
    strategy.entry("Long", strategy.long)

if (strategy.position_size > 0) // If in a long position
    strategy.exit("Exit Long", from_entry="Long", loss=stopLossPoints, profit=takeProfitPoints)
    // Optional: Close long if short condition appears (reversal)
    // if (shortEntryCondition)
    //     strategy.close("Long", comment="Reverse to Short")

// Manage Short Trades
if (shortEntryCondition and strategy.position_size == 0) // Only enter if flat
    strategy.entry("Short", strategy.short)

if (strategy.position_size < 0) // If in a short position
    strategy.exit("Exit Short", from_entry="Short", loss=stopLossPoints, profit=takeProfitPoints)
    // Optional: Close short if long condition appears (reversal)
    // if (longEntryCondition)
    //     strategy.close("Short", comment="Reverse to Long")

// To make it a reversing strategy (close current and open opposite):
// if (longEntryCondition) 
//     strategy.close("Short", comment = "Close Short for Long") // Close existing short if any
//     strategy.entry("Long", strategy.long)

// if (shortEntryCondition)
//     strategy.close("Long", comment = "Close Long for Short") // Close existing long if any
//     strategy.entry("Short", strategy.short)

In this combined version:

We have separate rsiLongThreshold and rsiShortThreshold for potentially different sensitivities.
pyramiding=0 in the strategy() declaration prevents adding to existing positions, ensuring only one trade (long or short) is active.
The logic strategy.position_size == 0 before strategy.entry() ensures we only enter a new trade if we are currently flat (no open position). This creates a “stop-and-wait” behavior between trades.
The commented-out sections show how one might implement a reversing strategy where a new signal in the opposite direction closes the current trade and opens a new one. For this, strategy.close() is used before strategy.entry().

Implementing Logic to Switch Between Long and Short

The primary concern is ensuring the strategy behaves as intended: does it wait for an exit before considering an opposite trade, or does an opposite signal reverse the current position?

Stop-and-Wait: Use strategy.position_size == 0 in entry conditions. A long position must hit its SL/TP or a specific exit condition before a short position can be considered, and vice-versa.

Reversing Strategy: If a long signal appears while short, close the short and go long. If a short signal appears while long, close the long and go short.

// For a reversing strategy (simplified)
if (longEntryCondition)
    strategy.close_all(comment = "Close for new Long") // Close any position
    strategy.entry("Long", strategy.long)

if (shortEntryCondition)
    strategy.close_all(comment = "Close for new Short") // Close any position
    strategy.entry("Short", strategy.short)

// SL/TP still applies to the open position
if (strategy.position_size != 0)
    strategy.exit("SL/TP", loss=stopLossPoints, profit=takeProfitPoints)

This simplified reversing logic closes any open trade if a new entry signal in either direction occurs. More granular control can be achieved by checking strategy.position_size before closing and entering.

Risk Management for Combined Strategies

Risk management remains paramount:

Consistent Position Sizing: Ensure your default_qty_value and default_qty_type are appropriate for your account size and risk tolerance. This applies whether you are long or short.
Overall Portfolio Risk: If trading multiple strategies or assets, consider the correlated risk.
Symmetrical vs. Asymmetrical Parameters: You might find that optimal SL/TP or indicator parameters differ for long and short sides due to market tendencies (e.g., markets may fall faster than they rise).

Backtesting Combined Long and Short Strategies

When backtesting a combined strategy:

Evaluate the performance of long and short trades separately if possible (Strategy Tester may provide some breakdown, or you can log trades manually for deeper analysis).
Assess if one side significantly outperforms the other. This might suggest specializing the strategy or refining the weaker side.
Pay attention to periods of whipsaw where the strategy might rapidly switch between long and short, accumulating losses. Filter conditions or regime filters can help here.

Advanced Techniques and Considerations

Beyond basic entry/exit logic, several advanced techniques can refine your long/short strategies.

Using Indicators to Enhance Long and Short Signals

Confluence: Require signals from multiple, uncorrelated indicators to confirm an entry. For example, add a volume condition or a volatility filter (e.g., ATR being above a certain threshold).

Regime Filters: Use a longer-term indicator (e.g., 200-period EMA) to determine the overall market trend. Only take long trades if price is above the 200 EMA and short trades if below.

// Regime Filter Example
longTermMA = ta.sma(close, 200)
isBullishRegime = close > longTermMA
isBearishRegime = close < longTermMA

longEntryCondition = baseLongCondition and isBullishRegime
shortEntryCondition = baseShortCondition and isBearishRegime

Custom Indicators: Develop your own indicators tailored to your specific edge or market observations.

Dynamic Position Sizing

Instead of fixed quantity or fixed percentage of equity, position sizing can be dynamic:

ATR-based Sizing: Adjust position size based on market volatility (Average True Range). Higher volatility leads to smaller position sizes to maintain consistent risk per trade.
pinescript atrValue = ta.atr(14) riskPerTradeUSD = 100 // Example: Risk $100 per trade positionSize = riskPerTradeUSD / (atrValue * syminfo.pointvalue) // For futures/stocks // Ensure to use strategy.order or strategy.entry with quantity = positionSize
Kelly Criterion (Advanced): A formula to determine optimal position size, though it can be aggressive and requires accurate win probability and payoff ratio estimates.

Alerts and Automation

alertcondition(): Create custom alert conditions within your strategy. These can be set up in TradingView to send notifications (email, SMS, app popup) when strategy events occur (e.g., entry signal, SL hit).
pinescript alertcondition(longEntryCondition, title="Long Signal", message="Potential Long Entry for {{ticker}}") alertcondition(shortEntryCondition, title="Short Signal", message="Potential Short Entry for {{ticker}}")
alert() function: For more dynamic alert messages or alerts triggered within if blocks based on complex state, use the alert() function (note: alert() calls are subject to Pine Script’s execution model and might trigger more frequently than alertcondition which typically triggers once per bar per condition met).
Webhook Automation: TradingView alerts can send POST requests to a webhook URL, enabling integration with third-party automated trading platforms or custom bots.

Common Pitfalls and How to Avoid Them

Overfitting (Curve Fitting): Designing a strategy that performs exceptionally well on historical data but fails in live trading. Avoidance: Use robust parameters, test on out-of-sample data, keep logic simple, and perform sensitivity analysis on parameters.
Look-Ahead Bias: Using information in your script that would not have been available at the time of the trade. Avoidance: Be meticulous with data indexing. Always use close[1], high[1], etc., if referring to data from the previous completed bar for decisions on the current bar.
Ignoring Transaction Costs: Forgetting to include commissions and slippage in backtests. Avoidance: Use the commission_value, commission_type, and slippage arguments in the strategy() declaration.
pinescript strategy("My Strategy", ..., commission_value=0.1, commission_type=strategy.commission.percent, slippage=2)
Repainting Code: Using functions or logic that cause historical indicator values or signals to change as new bars arrive (e.g., improper use of security() with future bars, timenow for historical calculations). Avoidance: Thoroughly understand how functions like security() work, especially its lookahead parameter. Test scripts visually by stepping through historical bars.
Insufficient Backtest Duration or Trades: Drawing conclusions from a small sample size. Avoidance: Test over various market conditions and ensure a statistically significant number of trades (hundreds, if possible).
Ignoring Drawdowns: Focusing solely on net profit without considering the maximum drawdown. Avoidance: Set acceptable drawdown limits and factor this into strategy viability.

By understanding these principles and progressively incorporating more sophisticated techniques, you can harness Pine Script to develop effective long and short trading strategies tailored to your analytical approach and risk profile.

Risk Warning

Code example is for educational purposes only and is not financial advice. Automated trading carries substantial risk of loss. Test thoroughly in a demo environment before considering live implementation. Past performance does not guarantee future results. Trade at your own risk and never risk more than you can afford to lose.