Pine Script: How to Verify an Open Position?

As experienced Pine Script developers know, accurately determining whether a trading strategy has an open position is crucial for robust strategy design. In this article, we’ll explore various techniques for verifying open positions, from basic checks to advanced methods that account for different order types and position management strategies.

Importance of Position Verification in TradingView

Knowing the state of your strategy’s positions is fundamental for several reasons. Primarily, it prevents conflicting signals and incorrect order execution. For example, you wouldn’t want to open a long position if one already exists, unless you intend to scale in. Moreover, it’s essential for calculating accurate profit/loss, adjusting stop-loss levels, and managing risk effectively.

Common Scenarios Requiring Position Verification

Position verification is needed in numerous scenarios:

• Avoiding duplicate entries: Ensuring a new trade isn’t initiated when one is already active.
• Scaling in/out: Properly managing position size when adding to or reducing an existing trade.
• Trailing stop-loss: Adjusting stop-loss levels dynamically based on the current position’s profitability.
• Conditional order placement: Triggering specific actions only when certain position criteria are met (e.g., profit targets).
• Backtesting Accuracy: Correctly simulating trading behavior during historical analysis.

Methods for Detecting Open Positions

Pine Script offers several built-in variables and functions to determine if a strategy is currently holding a position.

Using strategy.position_size to Check Position Size

The simplest and most common method involves using the strategy.position_size variable. This variable returns the absolute size of the current position. If it’s zero, no position is open. If it’s a positive number, a long position is open. A negative number indicates a short position.

//@version=5
strategy("Position Size Check", overlay=true)

if strategy.position_size > 0
    label.new(bar_index, high, "Long Position Open", color=color.green, style=label.style_labelup)
else if strategy.position_size < 0
    label.new(bar_index, low, "Short Position Open", color=color.red, style=label.style_labeldown)
else
    label.new(bar_index, close, "No Position Open", color=color.gray, style=label.style_labeldown)

Employing strategy.opentrades to Count Open Trades

strategy.opentrades returns the number of currently open trades. While less granular than strategy.position_size, it can be useful in specific situations, particularly when dealing with strategies that allow multiple simultaneous trades.

//@version=5
strategy("Open Trades Count", overlay=true)

openTrades = strategy.opentrades

plot(openTrades, title="Number of Open Trades")

Accessing Trade Information with strategy.opentrades.entry_price, strategy.opentrades.entry_time, etc.

For more detailed analysis, you can access individual trade information using functions like strategy.opentrades.entry_price(trade_number), strategy.opentrades.entry_time(trade_number), and similar functions for profit, loss, and quantity. Note that trade_number is zero-based index.

//@version=5
strategy("Trade Information", overlay=true)

if strategy.opentrades > 0
    entryPrice = strategy.opentrades.entry_price(0) // Get entry price of the first open trade
    label.new(bar_index, high, "Entry Price: " + str.tostring(entryPrice), color=color.blue)

Advanced Techniques for Open Position Verification

Combining Multiple Indicators for Robust Verification

In complex strategies, you might need to combine multiple indicators or conditions to verify a position’s validity. For example, you might check both strategy.position_size and a custom trend indicator to confirm that the position aligns with the overall market direction.

Handling Different Order Types (Market, Limit, Stop)

The core verification methods remain the same regardless of order type. The key difference lies in how you manage the initial order placement and the subsequent adjustments based on market behavior.

Accounting for Partial Fills and Scaling In/Out of Positions

When scaling in or out, you need to track the cumulative position size and average entry price. This can be achieved by storing the initial entry price and quantity and updating them whenever a new order is filled. The strategy.position_avg_price variable helps with this, automatically tracking the average entry price of the current position.

Practical Examples and Code Snippets

Example 1: Simple Position Check and Alert

This example displays an alert when a position is opened or closed.

//@version=5
strategy("Position Alert", overlay=true)

if strategy.position_size > 0 and strategy.position_size[1] == 0
    alert("Long position opened", alert.freq_once_per_bar)
else if strategy.position_size < 0 and strategy.position_size[1] == 0
    alert("Short position opened", alert.freq_once_per_bar)
else if strategy.position_size == 0 and strategy.position_size[1] != 0
    alert("Position closed", alert.freq_once_per_bar)

Example 2: Verifying Position Direction (Long or Short)

This example checks if the position is long or short and plots a colored background accordingly.

//@version=5
strategy("Position Direction", overlay=true)

longCondition = strategy.position_size > 0
shortCondition = strategy.position_size < 0

bgcolor(longCondition ? color.green : shortCondition ? color.red : na, title = "Position Background", transp=80)

Example 3: Calculating Position Profit/Loss Based on Open Price

This example calculates the profit/loss of the current position based on the entry price and current price.

//@version=5
strategy("Position P/L", overlay=true)

if strategy.position_size != 0
    entryPrice = strategy.position_avg_price
    currentPrice = close
    profitLoss = (currentPrice - entryPrice) * strategy.position_size
    plot(profitLoss, title="Profit/Loss")

Troubleshooting and Best Practices

Common Errors and How to Resolve Them

• Incorrectly interpreting strategy.position_size: Ensure you understand that positive values indicate long positions, negative values indicate short positions, and zero means no position.
• Not accounting for slippage and commission: These factors can affect the actual entry price and profit/loss. Consider incorporating them into your calculations for more accurate results.
• Race conditions: Be mindful of potential race conditions when multiple scripts or strategies are interacting. Use appropriate synchronization techniques to prevent conflicts.

Optimizing Performance for Real-time Verification

For real-time verification, avoid unnecessary calculations or complex logic within your position check. Use efficient data structures and algorithms to minimize the computational overhead.

Security Considerations when Handling Position Data

Be cautious about exposing sensitive position data to external sources. Limit the use of alert() function, because all alerts are public. Avoid storing position data in insecure locations.