Alerts we program in TradingView don"t show on the chart. That makes it cumbersome to test alert code. Thankfully with a bit of extra code we can highlight alert setups ourselves. Let"s see how we use up and down arrows for that.

Coding TradingView alerts is something we do with the alertcondition() function. Then when our script runs on the chart we activate those alert conditions when we enable and configure alerts by hand. From that point on whenever the alert setup occurs we get an alert pop-up, text message, or email.

But alertcondition() does have a limitation: it doesn"t show alerts on the chart (TradingView, n.d.; TradingView Wiki, 2018). That means we"ll have to inspect the chart ourselves to find historical alert setups. Troubleshooting alerts becomes harder as well: we can"t easily see how different parameters affect alert frequency.

Luckily, TradingView Pine also has features that we can use to highlight alerts ourselves. And all that requires is a bit of extra code. One way to see historical alert setups is to plot up and down arrows on the chart. Let"s see how we program that in TradingView.

We do three things to highlight alert setups with up and down arrows:

First we make a Boolean true/false variable. We set that variable"s value to true when the alert setup occurs. And have it be false when that setup isn"t present. When we store the alert setup in a variable like this, we can be sure that both the plotted arrows and alerts happen at the same time.

If we got two alert setups, the code for this step can be:

Next we use that Boolean variable with plotarrow(), a function that plots up and down arrows on the chart (TradingView, n.d.). Which arrow appears depends on the function"s series argument. When that argument is a positive value, an up arrow appear. A negative value gets us a down arrow, and with na no arrow appears.

So to make up and down arrows for the Boolean variables of the previous step we code:

Then we code the alert condition with TradingView"s alertcondition() function. To have that alert trigger at the same moment the plotted arrows appears on the chart, we execute alertcondition() with the Boolean variable we also used in the previous step.

The code of this step can look like:

Let"s see how we apply the above three steps to a complete TradingView indicator.

The example indicator below triggers alerts for inside and outside bar. An inside bar is a bar whose range is fully inside the bar that preceded it. And an outside bar occurs when a bar fully encompasses its previous bar (Pring, 2002). We have the indicator plot up arrows for inside bars and down arrows to highlight outside bars.

The indicator looks like this on the chart:

This is the source code of the complete indicator:

Let"s take the code apart to see what it does. First we define the indicator"s properties with the study() function:

Then we create true/false variables with the alert setups:

An inside bar is fully inside the range of the previous bar. So we look for when the bar"s low is greater than (>) the previous bar"s low (low[1]). And require that the high is less than (<) the previous high (high[1]). When those things happen at the same time, the current bar is an inside bar and our insideBar variable holds true (and false otherwise).

An outside bar has a range outside the preceding bar. So we check if the low is less than the previous low (low < low[1]) while the high is above the previous high (high > high[1]). Since we combine these two comparisons with the and operator, both have to be true before outsideBar becomes true too. When they don"t happen at the same time, outsideBar is false.

Next we use those Boolean variables to plot up and down arrows:

Here we call the plotarrow() function to make up and down arrows. Which of those gets plotted on the current bar depends on its series argument. To set that argument"s value we use two conditional operators here.

The first configuration options checks if insideBar is true. When it is, the operator returns 1 (which gets us an up arrow). Else the second conditional operator (?:) evaluates outsideBar. When that variable is true, this operator returns -1 (for a down arrow). Otherwise when both insideBar and outsideBar are false, we use na to disable a plotted arrow on the current bar.

With the colorup and colordown arguments of plotarrow() we make the arrows appear in fuchsia and yellow. With the maxheight argument we limit the arrows’ size.

Now that we got the arrows on the chart we make the alerts:

We code alert conditions with TradingView"s alertcondition() function. The first statement here triggers an alert when insideBar is true. The message of that alert says the current bar is an inside bar. Based on our alert settings that message can show as a pop-up, email, or SMS.

The next alertcondition() function call creates an alert condition for outside bars (outsideBar). Note that the conditions we code here only trigger once we create and configure each alert by hand. They won"t automatically fire simply because our script runs on the chart.

Besides noting alert setups with up and down arrows, we can bring attention to alerts through other ways. We can use these as an alternative to arrows, or use them alongside arrows. The other options we have are:

• We can colour the chart"s background when alert setups happen.
• Or we colour price bars to highlight alerts.
• A subtle way is to note alert setups with a plotted text character.
• We can also plot shapes on the chart for alert conditions.
• We can expand on that by plotting shapes with text for alert setups.
• But we can also only plot text when alerts happen.
• And with the plot() function we can show an alert"s trigger level on the chart.

Alert conditions we code with TradingView"s alertcondition() function don"t appear on the chart. That doesn"t help when we want to test our alert code or need to fix mistakes.

Luckily we can plot up and down arrows to highlight alert setups ourselves. That requires three actions. First we make a Boolean variable for each alert setup. Then we use that variable with TradingView"s plotarrow() function. That function plots up, down, or no arrows based on its series argument. Then in the final step we use the alert setup Boolean variable with alertcondition() to code the actual alert. That way both the arrows and alerts happen simultaneously.

One thing to note is that real-time and historical alert setups can differ. On historical data a TradingView indicator calculates once per bar, on bar close. But with real-time data the script processes every price update that happens in the chart"s last bar. Whether this makes your historical alert highlights underestimate the alert frequency depends on your manual alert settings.