How to Find the Price at a Specific Time in TradingView Pine Script?

As seasoned Pine Script developers, accessing historical data is a frequent requirement, whether for backtesting, custom indicators, or complex trading strategies. This article will explore various techniques to retrieve the price at a specific time within TradingView’s Pine Script environment, focusing on efficiency and accuracy.

Introduction to Accessing Historical Data in Pine Script

Understanding Pine Script’s Time Series Concept

Pine Script inherently works with time series data. Each variable (open, high, low, close, volume) is a series of values indexed by time. Understanding this sequential nature is crucial for manipulating historical data.

Limitations of Directly Accessing Past Prices

Directly accessing past prices using array-like indexing (e.g., close[10]) is limited to the current chart’s timeframe and the available historical bars loaded by TradingView. This method is suitable for relative offsets but not for arbitrary points in the past.

Overview of Methods for Retrieving Price at Specific Time

We’ll primarily focus on two methods:

1. request.security(): A powerful function to request data from other symbols or timeframes.
2. Custom logic with for loops and date/time comparisons: Provides more control but can be less efficient.

Using the request.security() Function for Historical Data

Explanation of request.security() Parameters (tickerid, timeframe, expression)

request.security(tickerid, timeframe, expression) is the workhorse for accessing historical data from different symbols or timeframes. Let’s break down the parameters:

• tickerid: The symbol you want to retrieve data from (e.g., “AAPL”, “BTCUSDT”).
• timeframe: The timeframe of the data you want to retrieve (e.g., “D”, “60”, “5”).
• expression: The Pine Script expression you want to evaluate on the requested data (e.g., close, high, sma(close, 20)).

Specifying the Ticker and Timeframe for Accurate Data Retrieval

Choosing the correct ticker and timeframe is vital. Mismatched timeframes can lead to incorrect or misleading results. Ensure the data source has sufficient history for your desired timeframe.

Implementing request.security() to Fetch Price at a Given Time

Unfortunately, request.security() doesn’t directly accept a specific timestamp. We need to request data from a timeframe that contains our target time and then filter the result. Here’s a common approach:

//@version=5
indicator("Price at Time", overlay=true)

target_time = timestamp("GMT+0", 2023, 1, 1, 12, 0) // Example: Jan 1, 2023, 12:00 GMT

//Request daily data.
daily_close = request.security(syminfo.tickerid, "D", close)

//Check if the current bar's time aligns with the target date.
target_date = timestamp("GMT+0", year(target_time), month(target_time), dayofmonth(target_time), 0, 0)

var float price_at_time = na

if time == target_date
    price_at_time := daily_close

plot(price_at_time, title="Price at Target Time", color=color.red, linewidth=2)

Note: This snippet retrieves the daily close and only works if your target time corresponds to the start of a trading day on the chart.

Implementing Custom Logic with for Loops and Date/Time Comparisons

Creating a Function to Search for Price Based on Timestamp

This method involves iterating through historical bars to find a matching timestamp. This is generally less efficient than request.security(), especially for longer timeframes.

Iterating Through Historical Bars to Find Matching Time

//@version=5
indicator("Price at Specific Time (Loop)", overlay=true)

target_time = timestamp("GMT+0", 2023, 1, 1, 12, 0)
var float price_at_time = na

for i = 0 to bar_index
    if time[i] == target_time
        price_at_time := close[i]
        break // Exit the loop once found

plot(price_at_time, title="Price at Target Time (Loop)", color=color.blue, linewidth=2)

Handling Edge Cases: Missing Data and Time Zone Considerations

• Missing Data: Be prepared for cases where data might be missing for your target time (e.g., holidays). Use na checks and conditional logic.
• Time Zones: Always be explicit about time zones. TradingView defaults to exchange time. Use the timestamp() function with the correct timezone offset.

Practical Examples and Code Snippets

Example 1: Retrieving the Closing Price at a Specific Date and Time

(Already covered in previous sections.)

Example 2: Finding the Highest High Within a Specific Time Window

//@version=5
indicator("Highest High in Time Window", overlay=true)

start_time = timestamp("GMT+0", 2023, 1, 1, 9, 0)
end_time   = timestamp("GMT+0", 2023, 1, 1, 17, 0)

var float highest_high = na

if time >= start_time and time <= end_time
    highest_high := na(highest_high) ? high : math.max(highest_high, high)

plot(highest_high, title="Highest High", color=color.green, linewidth=2)

Example 3: Using the Retrieved Price for Backtesting Strategies

//@version=5
strategy("Backtest with Specific Time", overlay=true)

target_time = timestamp("GMT+0", 2023, 1, 5, 10, 0)
daily_close = request.security(syminfo.tickerid, "D", close)

target_date = timestamp("GMT+0", year(target_time), month(target_time), dayofmonth(target_time), 0, 0)

var float price_at_time = na

if time == target_date
    price_at_time := daily_close

if not na(price_at_time) and close > price_at_time
    strategy.entry("Long", strategy.long)

This simplified backtesting example enters a long position if the current close is above the daily close on the target date. Remember to refine entry/exit conditions for a realistic strategy.

Best Practices and Considerations

Optimizing Script Performance for Historical Data Lookups

• Use request.security() whenever possible, as it’s generally more efficient than looping.
• Minimize the number of request.security() calls within your script.
• Consider using var to store retrieved prices if you only need to fetch them once.
• Avoid unnecessary calculations within the expression parameter of request.security(); perform them after retrieving the data.

Error Handling and Data Validation Techniques

• Check for na values in retrieved data, especially when dealing with different symbols or timeframes.
• Implement error handling for request.security() to gracefully handle ticker or timeframe errors.

Limitations and Workarounds for Data Availability

• TradingView only provides a limited history of data, especially for lower timeframes.
• Consider using higher timeframes if you need to access data further in the past.
• Be aware that some symbols may have gaps in their historical data.

Common Mistakes to Avoid When Accessing Historical Data

• Forgetting to account for time zones.
• Using the wrong ticker or timeframe.
• Not checking for na values.
• Overusing loops for historical data access.

By mastering these techniques and understanding the nuances of Pine Script, you can effectively retrieve price data at specific times, enabling you to build powerful and sophisticated trading indicators and strategies.