How to Get the First Bar of the Day in TradingView Pine Script?

Introduction to Identifying the First Bar of the Day in Pine Script

Analyzing specific periods within a trading day is fundamental to many strategies. Often, the open of the trading day sets the tone, and its initial price action holds significant weight. Identifying the first bar of the day in Pine Script is a common requirement for indicators and strategies that rely on this specific point in time.

Understanding the Importance of the First Bar

The first bar of the trading day, particularly for sessions like the NYSE or London open, represents the initial market reaction to overnight news or sentiment. Its high and low form the opening range, a critical concept in various trading methodologies (e.g., Breakout strategies). Understanding and capturing the data from this specific bar allows developers to build scripts that:

• Calculate the opening range.
• Look for breakouts above or below the opening range.
• Identify the initial direction bias of the day.
• Set daily pivots or support/resistance levels based on the open.
• Filter trades based on whether they occur within or outside the opening hours.

Accurately detecting this single bar amongst thousands is crucial for the logic and integrity of such scripts.

Overview of Built-in Variables for Time and Date in Pine Script

Pine Script provides several built-in variables and functions to work with time and date data for each bar:

• time: Returns the start time of the current bar in UNIX milliseconds, specific to the chart’s symbol’s exchange timezone. Crucially, it returns na outside of the session specified in the script or symbol settings.
• dayofmonth, dayofweek, month, year: Integer variables representing the respective date components for the current bar’s time.
• hour, minute, second: Integer variables representing the time components for the current bar’s time.
• syminfo.timezone: A string indicating the timezone of the symbol’s exchange.
• timeframe.period: A string representing the chart’s current timeframe (e.g., “D”, “60”, “15”).
• session.regular: A constant representing the symbol’s regular trading hours session as defined on TradingView.

Leveraging these variables, especially time, dayofmonth, and hour, allows us to programmatically determine if a given bar is the first of a new trading day.

Methods to Identify the First Bar of the Day

There are a few reliable methods to detect the first bar of the day. The choice often depends on whether you are focusing strictly on the regular session or any bar that marks a calendar day change.

Using dayofmonth and hour Variables

This method checks for a change in the calendar day from the previous bar, optionally combined with checking for the start hour of the trading session. It’s straightforward but might be sensitive to gaps or symbol settings.

//@version=5
indicator("First Bar Check (Day/Hour)", overlay=true)

// Get current day and hour
currentDay = dayofmonth
currentHour = hour

// Get previous day (using history operator [1])
prevDay = dayofmonth[1]

// Define the typical start hour (e.g., 9 for many equity markets, adjust as needed)
startHour = 9

// Check if the day has changed AND the current hour is the start hour
// or if it's the very first bar on the chart (handle edge case)
isFirstBarOfDay = (currentDay != prevDay) or (bar_index == 0)

// Optional: Combine with hour check for session start
isFirstRegularSessionBar = isFirstBarOfDay and (currentHour == startHour)

// Plot something to indicate the first bar
plotshape(isFirstBarOfDay, style=shape.circle, color=color.blue, location=location.top, size=size.small, title="New Calendar Day")
plotshape(isFirstRegularSessionBar, style=shape.triangleup, color=color.green, location=location.bottom, size=size.small, title="Start Hour Bar")

// Note: This approach assumes startHour is consistent and accounts for chart's timeframe.
// It may not be perfectly reliable across all symbols/timeframes due to pre/post market data.

This method is intuitive but relies on specific hour values, which might not align perfectly with the actual regular session start, especially for symbols with complex session definitions.

Employing time() Function with session.regular

This is generally the most robust method for identifying the first bar of the regular trading session for a symbol, regardless of its specific start hour or timezone. The time() function, when used without a specific session argument or implicitly using the chart’s session, returns na when the bar falls outside the session. The key is that it returns a valid timestamp at the start of the session.

//@version=5
indicator("First Bar Check (Time Function)", overlay=true)

// time(timeframe, session) returns the bar's time if it falls within the session,
// otherwise it returns na. By comparing the current bar's time() result to the
// previous bar's, we can detect the transition into the session.

// Get the bar time within the regular session. This will be 'na' for bars outside it.
currentTimeInSession = time(timeframe.period, session.regular)

// Check if the current bar is *in* the session (time is not na) AND the previous bar
// was *outside* the session (time[1] is na).
// Also handle the very first bar on the chart (it's the first bar of *its* session).

isFirstBarOfRegularSession = not na(currentTimeInSession) and na(currentTimeInSession[1])

// Plot something to indicate the first bar of the regular session
plotshape(isFirstBarOfRegularSession, style=shape.diamond, color=color.fuchsia, location=location.top, size=size.small, title="First Bar Regular Session")

// This method correctly identifies the start of the regular session regardless of
// timeframe (provided it's intra-day) or symbol timezone/session times.

This approach directly leverages Pine Script’s session handling, making it highly reliable for detecting the regular session start. It’s often preferred for strategies focused on the official trading day open.

Leveraging timestamp() Function

The timestamp() function creates a specific timestamp value for a given date and time. While powerful for comparing against fixed points in time or defining specific periods, it’s less intuitive than the time() method for simply finding the first bar of the day’s session start. You could potentially use it to get the timestamp of today’s and yesterday’s start hour and check if the current bar’s time falls between them, but this requires manually handling date rolling and time zones, making it overly complex for the common task of finding the very first bar of a session compared to the time() approach.

Its primary use case is defining specific, static points in time, not dynamically finding the first bar of each day as it occurs. Stick to time() with session.regular for this specific task unless you have a very specialized requirement involving absolute timestamp comparisons.

Pine Script Code Examples and Implementation

Let’s explore practical applications of the time() method, as it’s the most robust for finding the regular session’s first bar.

Example 1: Highlighting the First Bar of Each Day

This script simply marks the first bar of the regular session with a background color.

//@version=5
indicator("Highlight First Bar Daily Session", shorttitle="First Bar Highlight", overlay=true)

// Identify the first bar of the regular session using the time() function
isFirstBarOfRegularSession = not na(time(timeframe.period, session.regular)) and na(time(timeframe.period, session.regular)[1])

// Change background color for the first bar
bgcolor(isFirstBarOfRegularSession ? color.new(color.blue, 90) : na)

// You could also plot a vertical line or label
// if (isFirstBarOfRegularSession)
//     line.new(x1=bar_index, y1=low, x2=bar_index, y2=high, color=color.blue, width=1)
//     label.new(x=bar_index, y=high, text="OPEN", yloc=yloc.above, style=label.style_label_down, color=color.blue)

This visualization is useful for verifying the logic and seeing where the script identifies the session start on your chart.

Example 2: Calculating the Range of the First Bar

This example demonstrates how to capture the high and low prices specifically on the first bar and store them using var or varip for use throughout the day.

//@version=5
indicator("Daily Opening Range", shorttitle="OR", overlay=true)

// Identify the first bar of the regular session
isFirstBarOfRegularSession = not na(time(timeframe.period, session.regular)) and na(time(timeframe.period, session.regular)[1])

// Use 'var' to store the opening range values, retaining their value across bars.
// 'varip' is used here which also resets on intrepid bar updates, suitable for real-time.
varip float openingRangeHigh = na
varip float openingRangeLow = na

// If it's the first bar of the session, capture its high and low.
if isFirstBarOfRegularSession
    openingRangeHigh := high
    openingRangeLow := low
else
    // For subsequent bars in the same session, keep the captured values.
    // If we were outside the session, these would remain na until the next session starts.
    openingRangeHigh := openingRangeHigh[1]
    openingRangeLow := openingRangeLow[1]

// Calculate the range
openingRange = openingRangeHigh - openingRangeLow

// Plot the opening range levels and the range value (optional)
plot(openingRangeHigh, title="Opening Range High", color=color.green, linewidth=2)
plot(openingRangeLow, title="Opening Range Low", color=color.red, linewidth=2)
// plotchar(isFirstBarOfRegularSession, char='R', color=color.blue, location=location.top, size=size.small)

// Example usage: Check for breakout above high
breakoutCondition = close > openingRangeHigh and not na(openingRangeHigh)
// plotshape(breakoutCondition, style=shape.triangleup, color=color.lime, location=location.abovebar, size=size.small, title="Breakout Above OR")

// Display the calculated range (as a label or on the price scale)
// plot(openingRange, title="OR Size", display=display.data_window)

// Note: The 'varip' ensures that on the very first bar *update* within the session,
// the high/low are captured correctly even if the bar isn't closed yet.

Using varip (or var) is crucial here. Without them, openingRangeHigh and openingRangeLow would be reset to na on every subsequent bar after the first. varip ensures the value persists within the current chart session and resets appropriately at the start of a new session identified by isFirstBarOfRegularSession becoming true.

Example 3: Creating Alerts for the First Bar’s Conditions

Once you can identify the first bar and its properties, you can set up alerts based on conditions met at that moment or relative to its values later in the day.

//@version=5
indicator("First Bar Alerts Example", shorttitle="1st Bar Alert", overlay=true)

// Identify the first bar of the regular session
isFirstBarOfRegularSession = not na(time(timeframe.period, session.regular)) and na(time(timeframe.period, session.regular)[1])

// Capture opening range high/low as in the previous example
varip float orHigh = na
varip float orLow = na

if isFirstBarOfRegularSession
    orHigh := high
    orLow := low
else
    orHigh := orHigh[1]
    orLow := orLow[1]

// --- Alert Conditions Examples ---

// Alert 1: Alert immediately when the first bar is identified
alertcondition(isFirstBarOfRegularSession, "First Bar of Session Identified", "Triggered on the first bar of the regular session.")

// Alert 2: Alert if the first bar has a wide range (e.g., > 1% of its low)
firstBarWideRangeCondition = isFirstBarOfRegularSession and (orHigh - orLow) > (orLow * 0.01)
alertcondition(firstBarWideRangeRangeCondition, "First Bar Wide Range", "The first bar of the session had a range > 1%.")

// Alert 3: Alert if price breaks above the opening range high LATER in the day
breakoutAboveORCondition = close > orHigh and close[1] <= orHigh[1] and not na(orHigh)
// To avoid triggering on the first bar itself if close > orHigh there, add `and not isFirstBarOfRegularSession` if desired

alertcondition(breakoutAboveORCondition, "Breakout Above Opening Range", "Price broke above the opening range high.")

// Note: Ensure you set the Alert Frequency appropriately in the TradingView Alert settings (e.g., 'Once Per Bar Close' or 'Once Per Bar').

Alerts are a powerful way to automate notifications based on your script’s logic, and key events like the daily open are prime candidates for such automation.

Advanced Techniques and Considerations

While the time(timeframe.period, session.regular) method is robust, certain scenarios require deeper consideration.

Handling Different Time Zones

The time() function automatically handles the symbol’s exchange timezone (syminfo.timezone) when used with session.regular. This is a significant advantage and why this method is preferred. You generally don’t need to perform manual timezone conversions unless you are comparing times against a fixed UTC or specific non-exchange time or trying to define a custom session that isn’t pre-configured for the symbol.

If you were using the hour based method and needed to account for different time zones, you would need to know the session start hour in the exchange’s timezone and potentially adjust your code based on syminfo.timezone. This adds complexity, another reason to favor time().

Dealing with Extended Trading Hours

If your chart displays extended trading hours (pre-market, post-market), the time(timeframe.period, session.regular) method will correctly identify the start of the regular session. If your definition of the “first bar of the day” includes pre-market, then you would need to adjust your logic. A simple way is to check for the first bar where the dayofmonth variable changes compared to the previous bar, regardless of whether time() is na.

// Alternative check for the very first bar of the calendar day (might be pre-market)
isFirstCalendarBarOfDay = (dayofmonth != dayofmonth[1]) or (bar_index == 0)

This isFirstCalendarBarOfDay check is less concerned with the official session and more with the transition from one calendar day to the next on the chart’s timeline. Choose the method that aligns with your strategy’s definition of the “start of the day”.

Optimizing Code for Efficiency

Identifying the first bar is computationally light. The primary optimization consideration is how you handle variables that store data from the first bar for use on later bars. Using var or varip to declare variables outside of conditional blocks (if isFirstBarOfRegularSession) is key. This ensures the variable state persists from bar to bar. Assigning to these variables only when the condition is true (if isFirstBarOfRegularSession ... := ...) and potentially carrying forward the value otherwise (else ... := ...[1]) is the standard pattern for state management in Pine Script.

Avoid recalculating values derived from the first bar on every subsequent bar if they don’t change. Capture once, use many times.

Conclusion

Identifying the first bar of the trading day is a common and essential requirement for developing robust trading indicators and strategies in Pine Script. It provides a critical reference point for market analysis based on daily sessions.

Summary of Methods and Best Practices

We explored two primary methods: using dayofmonth and hour, and using the time() function with session.regular. While the dayofmonth/hour approach is simple, the time() method, specifically not na(time(...)) and na(time(...)[1]), is generally the most reliable and recommended way to detect the exact start of the symbol’s regular trading session, automatically handling time zones and specific session definitions.

Remember to use var or varip variables to correctly capture and store data from the first bar (like its high and low) so it remains accessible throughout the trading day for subsequent calculations or conditions.

Further Exploration and Resources

To deepen your understanding, explore Pine Script’s documentation on session handling and time functions. Experiment with different symbols to see how their sessions are defined and how time() behaves. Practice building scripts that use the opening range or other first-bar-derived data as inputs for entry signals, stops, or targets. Understanding how to manage variable state across bars using var and varip is fundamental to building any script that relies on data from previous bars or specific historical points.