How to Get Historical Close Prices in TradingView Pine Script?

Retrieving and utilizing historical data is fundamental to developing robust trading indicators and strategies in Pine Script. The close price, in particular, is a critical data point, representing the final consensus price for a given bar.

Introduction to Historical Close Prices in Pine Script

Historical close prices provide context, allowing traders and developers to analyze past market behavior, calculate lagging or leading indicators, and backtest trading hypotheses. Accessing this data correctly is paramount for accurate analysis and reliable script performance.

Why Use Historical Close Prices?

Historical close prices serve several crucial purposes:

• Indicator Calculation: Many standard and custom indicators (e.g., Moving Averages, RSI, MACD) require a series of past close prices.
• Backtesting and Strategy Development: Evaluating a strategy’s performance relies entirely on simulating trades based on historical price movements.
• Comparative Analysis: Comparing the current price action to historical patterns or levels.
• Multitimeframe Analysis: Using close prices from higher timeframes within a lower timeframe chart to gain broader market perspective.

Brief Overview of Pine Script and Its Limitations

Pine Script is TradingView’s domain-specific language for creating custom indicators and strategies. It operates on a bar-by-bar execution model. Each script run processes data for the current bar based on historical data available up to that bar. While powerful, Pine Script requires careful handling of historical data, particularly when accessing data from different symbols or timeframes, due to potential issues like na values, data gaps, and the intricacies of bar merging.

Using the security() Function to Access Historical Data

The primary function for accessing historical data from symbols or timeframes other than the chart the script is currently on is security(). While close[offset] accesses historical data on the current symbol/timeframe, security() is necessary for external data.

Understanding the security() Function Syntax

The basic syntax of security() is:

security(symbol, timeframe, expression, lookahead, barmerge)

• symbol: A string specifying the ticker symbol (e.g., “NASDAQ:AAPL”, “FX:EURUSD”). Use syminfo.tickerid for the current chart’s symbol ID.
• timeframe: A string specifying the timeframe (e.g., “D” for daily, “60” for 60 minutes, “W” for weekly). Use timeframe.period for the current chart’s timeframe.
• expression: The series or variable whose value you want to retrieve from the specified symbol and timeframe. To get the historical close price, this is simply close.
• lookahead: Controls how data is merged (barmerge.lookahead_on or barmerge.lookahead_off). Crucial for preventing repainting in strategy backtesting.
• barmerge: Controls the merging behavior (barmerge.gaps_on or barmerge.gaps_off). Determines how to handle gaps when the specified timeframe’s bars don’t align perfectly with the chart’s bars.

Specifying Ticker and Timeframe for Historical Close Prices

To fetch the close price, you set the expression argument to close. You then define the symbol and timeframe. For instance, to get the Daily close of the current chart’s symbol:

dailyClose = security(syminfo.tickerid, "D", close, barmerge.gaps_off, barmerge.lookahead_off)

Or, to get the 4-hour close of SPY:

spy4hClose = security("AMEX:SPY", "240", close, barmerge.gaps_off, barmerge.lookahead_off)

Note: Using barmerge.lookahead_off is generally recommended for strategy backtesting to avoid lookahead bias, as it prevents using data from the target bar’s future evolution.

Fetching Close Prices from Different Timeframes

Accessing higher timeframe close prices is a common use case. This is straightforward with security():

// Get the close price from the weekly timeframe
weeklyClose = security(syminfo.tickerid, "W", close, barmerge.gaps_off, barmerge.lookahead_off)

// Get the close price from the 30-minute timeframe
min30Close = security(syminfo.tickerid, "30", close, barmerge.gaps_off, barmerge.lookahead_off)

When the target timeframe is higher than the chart timeframe, the value from security() will remain constant across multiple bars of the chart timeframe until a new bar forms on the higher timeframe. For bars on the chart timeframe that fall within a higher timeframe bar, security() returns the last known value from the higher timeframe. For the first bar of the higher timeframe, it will return na until that bar closes, unless barmerge.lookahead_on is used (which can cause repainting).

Practical Examples of Retrieving Historical Close Prices

Let’s look at some practical applications.

Calculating Moving Averages Using Historical Close Prices

While you can calculate an SMA on the current timeframe using ta.sma(close, length), you might want an SMA from a higher timeframe or a different symbol. This requires security().

//@version=5
indicator("Higher Timeframe SMA", overlay=true)

htfInput = input.timeframe("D", "Higher Timeframe")
lengthInput = input.int(50, "SMA Length")

// Get the close series from the higher timeframe
htfClose = security(syminfo.tickerid, htfInput, close, barmerge.gaps_off, barmerge.lookahead_off)

// Calculate SMA on the higher timeframe close series
htfSma = ta.sma(htfClose, lengthInput)

// Plot the higher timeframe SMA on the current chart
plot(htfSma, color=color.blue, title="HTF SMA")

In this example, we fetch the daily close price (htfClose) and then calculate a 50-period SMA (htfSma) based on that daily data. This SMA is then plotted on the current chart timeframe (e.g., H1, M15), appearing as steps.

Comparing Current Close with Previous Day’s Close

To compare the current bar’s close with the previous day’s close, you can use security() or, if the chart timeframe is lower than Daily, look back to a previous daily bar. A simple approach using security() is robust across various chart timeframes:

//@version=5
indicator("Close vs Previous Day Close", overlay=false)

// Get the close price from the daily timeframe, without lookahead bias
dailyCloseSeries = security(syminfo.tickerid, "D", close[0], barmerge.gaps_off, barmerge.lookahead_off)

// Access the previous day's close from the fetched daily series
prevDayClose = dailyCloseSeries[1]

// Compare current close with previous day's close (handles intraday updates)
currentCloseVal = close

plot(currentCloseVal, title="Current Close", color=color.blue)
plot(prevDayClose, title="Previous Day Close", color=color.red)

// Check if current close is higher than previous day's close (at the end of the current bar)
isHigher = currentCloseVal > prevDayClose

bgcolor(isHigher ? color.new(color.green, 90) : color.new(color.red, 90))

Here, close[0] is used within security to get the current bar’s close value on the Daily timeframe. [1] is then applied to the series returned by security() to access the previous Daily close. The background color highlights if the current close is above the previous day’s close.

For simple lookbacks on the current timeframe, the offset operator [] is sufficient:

// Current timeframe close 1 bar ago
close1BarAgo = close[1]

// Current timeframe close 10 bars ago
close10BarsAgo = close[10]

Implementing a Simple Strategy Based on Historical Data

Let’s create a basic strategy that buys when the current price crosses above a Weekly 20-period Moving Average and sells when it crosses below.

//@version=5
strategy("HTF SMA Cross Strategy", overlay=true)

// Get the close series from the Weekly timeframe
weeklyClose = security(syminfo.tickerid, "W", close, barmerge.gaps_off, barmerge.lookahead_off)

// Calculate the Weekly 20-period SMA
weeklySMA20 = ta.sma(weeklyClose, 20)

// Define crossover conditions based on current price and weekly SMA
longCondition = ta.crossover(close, weeklySMA20)
shortCondition = ta.crossunder(close, weeklySMA20)

// Execute trades
if longCondition
    strategy.entry("Buy", strategy.long)

if shortCondition
    strategy.close("Buy") // Close long position on sell signal
    // Optional: strategy.entry("Sell", strategy.short) for short trades

// Plot the Weekly SMA for visualization
plot(weeklySMA20, color=color.purple, title="Weekly SMA 20")

This strategy demonstrates how security() can fetch a signal or filter (the Weekly SMA) from a higher timeframe to influence trading decisions on the current, potentially lower, chart timeframe. Using barmerge.lookahead_off is crucial here to prevent lookahead bias during backtesting.

Troubleshooting and Limitations When Working with Historical Data

Working with historical data, especially across timeframes, presents challenges.

Handling na Values and Data Gaps

security() can return na (Not a Number) under several circumstances:

• When requesting data for a bar that doesn’t exist in the historical record.
• On the very first bars of the chart, where the requested historical lookback is longer than the available data.
• On the current bar of a higher timeframe when using barmerge.lookahead_off – the value is na until the higher timeframe bar closes.
• When there are data gaps for the requested symbol/timeframe.

Using ta.valuewhen(), na.fill(), or checking for na with na() before calculations is often necessary to handle these cases and prevent script errors or unexpected behavior.

// Example: Filling na values of a HTF series with the last known value
htfCloseFilled = na.fill(htfClose, htfClose[1])

Understanding Repainting and Lookahead Bias

• Repainting: Occurs when an indicator’s past plot changes as new data comes in. This is often caused by using security() with barmerge.lookahead_on on intraday timeframes, where the fetched value for the current higher timeframe bar updates multiple times as the price moves. Repainting makes backtest results appear overly optimistic because the script uses data that wasn’t actually available at the time the historical bar closed.
• Lookahead Bias: Using future information in calculations. security() with barmerge.lookahead_on introduces this bias because it provides the final value of the higher timeframe bar before that bar has actually closed on the lower chart timeframe.

Mitigation: Always use barmerge.lookahead_off in strategy backtesting and for indicators where avoiding repainting is critical for accurate historical representation. Be aware that barmerge.lookahead_off will yield na on the current bar for the fetched series until the target timeframe bar closes.

Common Errors and How to Resolve Them

• “Study Error: Could not find history for that ticker”: The specified symbol or timeframe might be incorrect or unavailable on TradingView.
• “Study Error: security() is not allowed to use future data. Fix lookahead or use barmerge.lookahead_off”: You are likely using barmerge.lookahead_on in a strategy or context where it’s causing lookahead bias. Change to barmerge.lookahead_off.
• na values propagating errors: Ensure you handle potential na returns from security() using functions like na.fill(), ta.valuewhen(), or explicit na() checks before performing arithmetic operations.

Advanced Techniques and Considerations

Beyond basic retrieval, consider these points.

Combining Historical Data with Real-Time Data

Many scripts require calculations involving both historical data from security() and the current bar’s developing data (close, open, high, low). Ensure your logic correctly handles the potential na values from security() on the current bar if barmerge.lookahead_off is used. You might check barstate.isrealtime or barstate.isconfirmed to apply logic differently on the last, potentially incomplete, bar.

Optimizing Script Performance When Accessing Historical Data

• max_bars_back: The security() function’s performance is impacted by how many historical bars it needs to process. While Pine Script handles this automatically, being mindful of requesting extremely long history on very low timeframes can impact loading speed. Pine v5 has improved handling, but for very complex calculations on historical data, consider optimizing the expression passed to security() or pre-calculating parts if possible.
• Number of security() Calls: Minimizing redundant security() calls fetching the same data can improve performance. Store the result of a security() call in a variable and reuse it.

Utilizing Historical Data for Backtesting

Accurate backtesting depends on correctly accessing and interpreting historical data. Using security() with barmerge.lookahead_off is non-negotiable for reliable strategy backtesting. Ensure your script uses the data as it would have been available at the time of the historical bar’s close to avoid inflated performance metrics.

Mastering the retrieval and handling of historical close prices via security() and the offset operator [] is essential for any serious Pine Script developer aiming to build sophisticated and reliable trading tools.