Pine Script

https://www.tradingview.com/pine-script-docs/v5/
Admin
Pine Script is TradingView's programming language for creating custom trading indicators and...
Tokens:589,019
Snippets:2,927
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### strategy.exit() qty_percent example

Source: https://www.tradingview.com/pine-script-docs/v5/release-notes

Example strategy showing how qty_percent now applies to the initial position size. Each strategy.exit() call closes 20% of the initial position, not the remaining position.

```pine
//@version=5
strategy("strategy.exit() example", overlay = true)
strategy.entry("Long", strategy.long, qty = 100)
strategy.exit("Exit Long1", "Long", trail_points = 50, trail_offset = 0, qty_percent = 20)
strategy.exit("Exit Long2", "Long", trail_points = 100, trail_offset = 0, qty_percent = 20)
```

--------------------------------

### Modulo function example

Source: https://www.tradingview.com/pine-script-docs/v5/language/operators

Shows how the modulo operator is calculated using math.floor and nz. The example defines a modulo function and plots the result of modulo(-1, 100).

```Pine Script
//@version=5
indicator("Modulo function")
modulo(series int a, series int b) =>
    a - b * math.floor(nz(a/b))
plot(modulo(-1, 100))

```

--------------------------------

### Label text alignment example

Source: https://www.tradingview.com/pine-script-docs/v5/release-notes

Shows how to use the new textalign parameter in label.new to align label text. The example creates a label with right-aligned text and sets its position.

```pine
//@version=4  
study("My Script", overlay = true)  
var l = label.new(bar_index, high, text="Right\n aligned\n text", textalign=text.align_right)  
label.set_xy(l, bar_index, high)
```

--------------------------------

### Example library: AllTimeHighLow

Source: https://www.tradingview.com/pine-script-docs/v5/concepts/libraries

A complete example library that exports functions to calculate the all-time high and low of a series. It uses the library() declaration and includes plot() calls in the global scope to demonstrate usage.

```pine
//@version=5

// @description Provides functions calculating the all-time high/low of values.
library("AllTimeHighLow", true)

// @function Calculates the all-time high of a series.
// @param val Series to use (`high` is used if no argument is supplied).
// @returns The all-time high for the series.
export hi(float val = high) =>
    var float ath = val
    ath := math.max(ath, val)

// @function Calculates the all-time low of a series.
// @param val Series to use (`low` is used if no argument is supplied).
// @returns The all-time low for the series.
export lo(float val = low) =>
    var float atl = val
    atl := math.min(atl, val)

plot(hi())
plot(lo())
```

--------------------------------

### Base script: Aggregate ROC with for loop

Source: https://www.tradingview.com/pine-script-docs/v5/writing/debugging

Starting point for debugging examples. Aggregates the close value's rates of change over 1 to lookbackInput bars in a for loop, then divides by lookbackInput to get an average. The aroc variable is global and modified inside the loop, while pastClose and roc are local.

```Pine Script
//@version=5
indicator("Debugging loops demo", "Aggregate ROC")

//@variable The number of bars in the calculation.
int lookbackInput = input.int(20, "Lookback", 1)

//@variable The average ROC of `close` prices over each length from 1 to `lookbackInput` bars.
float aroc = 0.0

// Calculation loop.
for length = 1 to lookbackInput
    //@variable The `close` value `length` bars ago.
    float pastClose = close[length]
    //@variable The `close` rate of change over `length` bars.
    float roc = (close - pastClose) / pastClose
    // Add the `roc` to `aroc`.
    aroc += roc

// Divide `aroc` by the `lookbackInput`.
aroc /= lookbackInput

// Plot the `aroc`.
plot(aroc, "aroc", color.blue, 3)
```

--------------------------------

### Array support example

Source: https://www.tradingview.com/pine-script-docs/v5/release-notes

Shows how to use the new array feature to build custom datasets.

```Pine Script
//@version=4
study("My Script")
a = array.new_float(0)
for i = 0 to 5
    array.push(a, close[i] - open[i])
plot(array.get(a, 4))
```

--------------------------------

### Valid and invalid identifier examples

Source: https://www.tradingview.com/pine-script-docs/v5/language/identifiers

Shows examples of valid identifiers (myVar, _myVar, my123Var, functionName, MAX_LEN, max_len, maxLen) and an invalid one (3barsDown) that starts with a digit.

```Pine Script
myVar
_myVar
my123Var
functionName
MAX_LEN
max_len
maxLen
3barsDown  // NOT VALID!
```

--------------------------------

### if without else returning na

Source: https://www.tradingview.com/pine-script-docs/v5/language/conditional-structures

Shows that when the else block is omitted and the condition is false, the variable gets na. In this example, if close > open is false, x is na.

```Pine Script
x = if close > open  
    close  
```

--------------------------------

### Multiple TP Demo with OCA group (strategy.oca.reduce example)

Source: https://www.tradingview.com/pine-script-docs/v5/concepts/strategies

Corrected version of the previous example. Adds oca_name = "Bracket" and oca_type = strategy.oca.reduce to all strategy.order() calls, so unfilled orders reduce after one executes. Note the qty of "Limit 2" is changed to 6 to avoid it dropping to 0.

```Pine Script
//@version=5
strategy("Multiple TP Demo", overlay = true)

var float stop   = na
var float limit1 = na
var float limit2 = na

bool longCondition = ta.crossover(ta.sma(close, 5), ta.sma(close, 9))
if longCondition and strategy.position_size == 0
    stop   := close * 0.99
    limit1 := close * 1.01
    limit2 := close * 1.02
    strategy.entry("Long",  strategy.long, 6)
    strategy.order("Stop",  strategy.short, stop = stop, qty = 6, oca_name = "Bracket", oca_type = strategy.oca.reduce)
    strategy.order("Limit 1", strategy.short, limit = limit1, qty = 3, oca_name = "Bracket", oca_type = strategy.oca.reduce)
    strategy.order("Limit 2", strategy.short, limit = limit2, qty = 6, oca_name = "Bracket", oca_type = strategy.oca.reduce)

bool showPlot = strategy.position_size != 0
plot(showPlot ? stop   : na, "Stop",    color.red,   style = plot.style_linebr)
plot(showPlot ? limit1 : na, "Limit 1", color.green, style = plot.style_linebr)
plot(showPlot ? limit2 : na, "Limit 2", color.green, style = plot.style_linebr)
```

--------------------------------

### Initialization with na example

Source: https://www.tradingview.com/pine-script-docs/v5/language/variable-declarations

Shows three ways to initialize a variable with na: one causes a compile-time error, the other two are valid.

```pine
baseLine0 = na          // compile time error!
float baseLine1 = na    // OK
baseLine2 = float(na)   // OK
```

--------------------------------

### Line wrapping: color.from_gradient

Source: https://www.tradingview.com/pine-script-docs/v5/writing/profiling-and-optimization

Example of a wrapped line in the Pine Editor. The Profiler treats all portions as part of the first line where it starts, and the tooltip shows single-line results with the line number of the first line.

```Pine Script
color oscColor = oscillator > 0 ?
     color.from_gradient(oscillator, 0.0, 1.0, color.gray, color.green) :
     color.from_gradient(oscillator, -1.0, 0.0, color.red, color.gray)
```

--------------------------------

### input.color support example

Source: https://www.tradingview.com/pine-script-docs/v5/release-notes

Demonstrates using input.color to provide a color selection in the script's Settings/Inputs tab.

```Pine Script
//@version=4
study("My Script", overlay = true)
color c_labelColor = input(color.green, "Main Color", input.color)
var l = label.new(bar_index, close, yloc = yloc.abovebar, text = "Colored label")
label.set_x(l, bar_index)
label.set_color(l, c_labelColor)
```

--------------------------------

### Global and local scope example

Source: https://www.tradingview.com/pine-script-docs/v5/language/script-structure

Illustrates global and local scopes in Pine Script v5. The function declaration and variable declaration contain local blocks indented by four spaces, while global statements start at the first character.

```pine
//@version=5

indicator("", "", true)    // Declaration statement (global scope)

barIsUp() =>    // Function declaration (global scope)
    close > open    // Local block (local scope)

plotColor = if barIsUp()  // Variable declaration (global scope)
    color.green     // Local block (local scope)
else
    color.red       // Local block (local scope)

bgcolor(color.new(plotColor, 70))   // Call to a built-in function  (global scope)

```

--------------------------------

### Line Wrapping Example

Source: https://www.tradingview.com/pine-script-docs/v5/language/script-structure

Demonstrates how to wrap a long line by splitting it across multiple lines with indentation that is not a multiple of four spaces.

```Pine Script
a = open + high + low + close
```

```Pine Script
a = open +
      high +
          low +
             close
```

--------------------------------

### Style guide identifier examples

Source: https://www.tradingview.com/pine-script-docs/v5/language/identifiers

Recommended naming conventions: uppercase SNAKE_CASE for constants (GREEN_COLOR, MAX_LOOKBACK) and camelCase for other identifiers (fastLength, zeroOne). The zeroOne function returns 1 if the argument is true, 0 if false or na.

```Pine Script
GREEN_COLOR = #4CAF50
MAX_LOOKBACK = 100
int fastLength = 7
// Returns 1 if the argument is `true`, 0 if it is `false` or `na`.
zeroOne(boolValue) => boolValue ? 1 : 0
```

--------------------------------

### Find the first index of an array element using array.indexof()

Source: https://www.tradingview.com/pine-script-docs/v5/faq/data-structures

Use array.indexof() to get the index of the first occurrence of a value. Returns -1 if not found. Does not indicate multiple occurrences. The example searches for a user-input value and displays the index or 'not found'.

```Pine Script
//@version=5  
indicator("Example: Find index of array element")  
array<float> prices = array.from(100.5, 101.2, 102.8, 100.5)  
float searchValue = input(101.2, "Value to Search For")  
int indexFound = array.indexof(prices, searchValue)  
if barstate.islast  
    string lblString = switch  
        indexFound < 0 => "Search value: not found"  
        =>                "Search value: found\n       Index: " + str.tostring(indexFound)  
    label.new(bar_index, high, lblString,  
         textcolor        = color.white,  
         textalign        = text.align_left,  
         text_font_family = font.family_monospace  
     )  
```

--------------------------------

### Retrieve map keys and values with map.keys() and map.values()

Source: https://www.tradingview.com/pine-script-docs/v5/language/maps

Shows how map.keys() and map.values() return arrays ordered by the map's insertion order. The example creates a map, inserts three key-value pairs, and displays the resulting key and value arrays in a label every 50 bars. The first value is a random whole number between 0 and 100, the second is one greater, and the third is one greater than the second.

```Pine Script
//@version=5
indicator("Keys and values demo")

if bar_index % 50 == 0
    //@variable A map containing pairs of `string` keys and `float` values.
    m = map.new<string, float>()

    // Put pairs into `m`. The map will maintain this insertion order.
    m.put("First", math.round(math.random(0, 100)))
    m.put("Second", m.get("First") + 1)
    m.put("Third", m.get("Second") + 1)

    //@variable An array containing the keys of `m` in their insertion order.
    array<string> keys = m.keys()
    //@variable An array containing the values of `m` in their insertion order.
    array<float> values = m.values()

    //@variable A label displaying the `size` of `m` and the `keys` and `values` arrays.
    label debugLabel = label.new(
         bar_index, 0,
         str.format("Pairs: {0}\nKeys: {1}\nValues: {2}", m.size(), keys, values),
         color = color.navy, style = label.style_label_center, 
         textcolor = color.white, size = size.huge
     )
```

--------------------------------

### Custom MA function with percentile-based smoothing

Source: https://www.tradingview.com/pine-script-docs/v5/writing/debugging

Starting point for debugging examples. Defines a customMA() function that returns an exponential moving average with a smoothing parameter varying based on the source distance outside the 25th and 75th percentiles over a given length. Uses ta.percentile_linear_interpolation and ta.range.

```Pine Script
//@version=5  
indicator("Debugging functions demo", "Custom MA", true)  
  
//@variable The number of bars in the `customMA()` calculation.  
int lengthInput = input.int(50, "Length", 2)  
  
//@function      Calculates a moving average that only responds to values outside the first and third quartiles.  
//@param source  The series of values to process.  
//@param length  The number of bars in the calculation.  
//@returns       The moving average value.  
customMA(float source, int length) =>  
    //@variable The custom moving average.  
    var float result = na  
    // Calculate the 25th and 75th `source` percentiles.  
    float q1 = ta.percentile_linear_interpolation(source, length, 25)  
    float q3 = ta.percentile_linear_interpolation(source, length, 75)  
    // Calculate the range values.  
    float outerRange = math.max(source - q3, q1 - source, 0.0)  
    float totalRange = ta.range(source, length)  
    //@variable Half the ratio of the `outerRange` to the `totalRange`.  
    float alpha = 0.5 * outerRange / totalRange  
    // Mix the `source` with the `result` based on the `alpha` value.  
    result := (1.0 - alpha) * nz(result, source) + alpha * source  
    // Return the `result`.  
    result  
  
//@variable The `customMA()` result over `lengthInput` bars.  
float maValue = customMA(close, lengthInput)  
  
// Plot the `maValue`.  
plot(maValue, "Custom MA", color.blue, 3)  
```

--------------------------------

### Request chart points from higher timeframe and draw boxes

Source: https://www.tradingview.com/pine-script-docs/v5/concepts/other-timeframes-and-data

Uses chart.point.now() and chart.point.from_time() to get coordinates from the last confirmed bar, then requests them from a higher timeframe with request.security(). Draws a new box when a higher timeframe bar starts. Raises a runtime error if the selected timeframe is smaller than the chart's timeframe.

```Pine Script
//@version=5  
indicator("Requesting chart points demo", "HTF Boxes", true, max_boxes_count = 500)  
  
//@variable The timeframe to request data from.  
string higherTimeframe = input.timeframe("1D", "Timeframe")  
  
// Raise a runtime error if the `higherTimeframe` is smaller than the chart's timeframe.  
if timeframe.in_seconds(higherTimeframe) < timeframe.in_seconds(timeframe.period)  
    runtime.error("The selected timeframe is too small. Choose a higher timeframe.")  
  
//@variable A `chart.point` containing top-left coordinates from the last confirmed bar.  
topLeft = chart.point.now(high)[1]  
//@variable A `chart.point` containing bottom-right coordinates from the last confirmed bar.  
bottomRight = chart.point.from_time(time_close, low)[1]  
  
// Request the last confirmed `topLeft` and `bottomRight` chart points from the `higherTimeframe`.  
[requestedTopLeft, requestedBottomRight] = request.security(  
     syminfo.tickerid, higherTimeframe, [topLeft, bottomRight], lookahead = barmerge.lookahead_on  
 )  
  
// Draw a new box when a new `higherTimeframe` bar starts.  
// The box uses the `time` fields from the `requestedTopLeft` and `requestedBottomRight` as x-coordinates.  
if timeframe.change(higherTimeframe)  
    box.new(  
         requestedTopLeft, requestedBottomRight, color.purple, 3,   
         xloc = xloc.bar_time, bgcolor = color.new(color.purple, 90)  
     )  

```

--------------------------------

### Create exit bracket orders with strategy.exit() in Pine Script

Source: https://www.tradingview.com/pine-script-docs/v5/concepts/strategies

This Pine Script example places a market entry order when the high equals the highest high, and creates take-profit and stop-loss exit orders using strategy.exit() with limit and stop arguments. It also plots the highest high and lowest low values. Note that no qty is specified, so the exit orders close 100% of the entry order's size.

```Pine Script
//@version=5  
strategy(  
     "Verify price for limits example", overlay = true,  
     default_qty_type = strategy.percent_of_equity, default_qty_value = 2  
 )  

int length = input.int(25, title = "Length")  

//@variable Draws a line at the limit price of the most recent entry order.  
var line limitLine = na  

// Highest high and lowest low  
highest = ta.highest(length)  
lowest  = ta.lowest(length)  

// Place an entry order and draw a new line when the the `high` equals the `highest` value and `limitLine` is `na`.  
if high == highest and na(limitLine)  
    float limitPrice = hlcc4  
    strategy.entry("Long", strategy.long, limit = limitPrice)  
    limitLine := line.new(bar_index, limitPrice, bar_index + 1, limitPrice)  

// Close the open market position, cancel orders, and set `limitLine` to `na` when the `low` equals the `lowest` value.  
if low == lowest  
    strategy.cancel_all()  
    limitLine := na  
    strategy.close_all()  

// Update the `x2` value of `limitLine` if it isn't `na`.  
if not na(limitLine)  
    limitLine.set_x2(bar_index + 1)  

plot(highest, "Highest High", color = color.new(color.green, 50))  
plot(lowest, "Lowest Low", color = color.new(color.red, 50))  

```

--------------------------------

### Non-repainting HTF data request with barmerge.lookahead_on and offset

Source: https://www.tradingview.com/pine-script-docs/v5/concepts/other-timeframes-and-data

This example avoids repainting by adding lookahead = barmerge.lookahead_on to request.security() and offsetting the ta.wma() call by one bar with the history-referencing operator []. This ensures the request always retrieves the last confirmed HTF bar's WMA at the start of each new timeframe, providing consistent behavior on historical and realtime bars.

```Pine Script
//@version=5  
indicator("Avoiding HTF repainting demo", overlay = true)  
  
//@variable The multiplier applied to the chart's timeframe.  
int tfMultiplier = input.int(10, "Timeframe multiplier", 1)  
//@variable The number of bars in the moving average.  
int length = input.int(5, "WMA smoothing length")  
  
//@variable The valid timeframe string closest to `tfMultiplier` times larger than the chart timeframe.  
string timeframe = timeframe.from_seconds(timeframe.in_seconds() * tfMultiplier)  
  
//@variable The weighted MA of `close` prices over `length` bars on the `timeframe`.  
//          This request does not repaint, as it always references the last confirmed WMA value on all bars.  
float requestedWMA = request.security(  
     syminfo.tickerid, timeframe, ta.wma(close, length)[1], lookahead = barmerge.lookahead_on  
 )  
  
// Plot the requested value.  
plot(requestedWMA, "HTF WMA", color.purple, 3)  
// Highlight the background on realtime bars.  
bgcolor(barstate.isrealtime ? color.new(color.orange, 70) : na, title = "Realtime bar highlight")  

```

--------------------------------

### Create array with array.from()

Source: https://www.tradingview.com/pine-script-docs/v5/language/arrays

This example creates the same fillColors array with a single call to array.from(), passing the color values as arguments. It then cycles the background through the array's colors using array.get() and the array's size.

```Pine Script
//@version=5  
indicator("Using `var`")  
FILL_COLOR = color.green  
var array<color> fillColors = array.from(  
     color.new(FILL_COLOR, 70),  
     color.new(FILL_COLOR, 75),  
     color.new(FILL_COLOR, 80),  
     color.new(FILL_COLOR, 85),  
     color.new(FILL_COLOR, 90)  
 )  
// Cycle background through the array's colors.  
bgcolor(array.get(fillColors, bar_index % (fillColors.size())))  

```

--------------------------------

### Single-line function example

Source: https://www.tradingview.com/pine-script-docs/v5/language/user-defined-functions

Example of a single-line function that adds two arguments.

```pine
f(x, y) => x + y
```

--------------------------------

### Multi-line function example

Source: https://www.tradingview.com/pine-script-docs/v5/language/user-defined-functions

Example of a multi-line function that calculates the geometric average of two values.

```pine
geom_average(x, y) =>
    a = x*x
    b = y*y
    math.sqrt(a + b)
```

--------------------------------

### Function declarations with documentation comments

Source: https://www.tradingview.com/pine-script-docs/v5/writing

Example of a user-defined function in the global scope, using documentation comments and a switch statement to map user input to size constants. It demonstrates the recommended style for documenting functions and handling dependencies on global variables.

```Pine Script
//@version=6  
indicator("<function_declarations>", "", true)  
  
string SIZE_LARGE  = "Large"  
string SIZE_NORMAL = "Normal"  
string SIZE_SMALL  = "Small"  
  
string sizeInput = input.string(SIZE_NORMAL, "Size", options = [SIZE_LARGE, SIZE_NORMAL, SIZE_SMALL])  
  
// @function        Used to produce an argument for the `size` parameter in built-in functions.  
// @param userSize  (simple string) User-selected size.  
// @returns         One of the `size.*` built-in constants.  
// Dependencies     SIZE_LARGE, SIZE_NORMAL, SIZE_SMALL  
getSize(simple string userSize) =>  
    result =   
      switch userSize  
        SIZE_LARGE  => size.large  
        SIZE_NORMAL => size.normal  
        SIZE_SMALL  => size.small  
        => size.auto  
  
if ta.rising(close, 3)  
    label.new(bar_index, na, yloc = yloc.abovebar, style = label.style_arrowup, size = getSize(sizeInput))  

```

--------------------------------

### Initialize array with array.unshift()

Source: https://www.tradingview.com/pine-script-docs/v5/language/arrays

This code is equivalent to the array.push() example but uses array.unshift() to insert new elements at the beginning of the fillColors array.

```Pine Script
// Declare array and set its values on the first bar only.  
var fillColors = array.new<color>(0)  
if barstate.isfirst  
    // Initialize the array elements with progressively lighter shades of the fill color.  
    array.unshift(fillColors, color.new(FILL_COLOR, 90))  
    array.unshift(fillColors, color.new(FILL_COLOR, 85))  
    array.unshift(fillColors, color.new(FILL_COLOR, 80))  
    array.unshift(fillColors, color.new(FILL_COLOR, 75))  
    array.unshift(fillColors, color.new(FILL_COLOR, 70))  

```

--------------------------------

### Array example with table display

Source: https://www.tradingview.com/pine-script-docs/v5/faq/data-structures

Declares an array of 5 float elements, pushes the current close on each bar, shifts out the oldest element, and displays the array in a table on the last bar.

```Pine Script
//@version=5
indicator("Array example")
// Declare an array with 5 `na` values on the first bar.
var array<float> pricesArray = array.new<float>(5)
// On each bar, add a new value to the end of the array and remove the first (oldest) element.
array.push(pricesArray, close)
array.shift(pricesArray)
// Display the array and its contents in a table.
var table displayTable = table.new(position.middle_right, 1, 1)
if barstate.islast
    table.cell(displayTable, 0, 0, str.tostring(pricesArray), text_color = chart.fg_color)

```

--------------------------------

### Initialize array with array.push()

Source: https://www.tradingview.com/pine-script-docs/v5/language/arrays

This code initializes an empty array and appends new elements to the end using array.push(). It is functionally identical to the initialization section of the previous example.

```Pine Script
// Declare array and set its values on the first bar only.  
var fillColors = array.new<color>(0)  
if barstate.isfirst  
    // Initialize the array elements with progressively lighter shades of the fill color.  
    array.push(fillColors, color.new(FILL_COLOR, 70))  
    array.push(fillColors, color.new(FILL_COLOR, 75))  
    array.push(fillColors, color.new(FILL_COLOR, 80))  
    array.push(fillColors, color.new(FILL_COLOR, 85))  
    array.push(fillColors, color.new(FILL_COLOR, 90))  

```
Tokens:
Raw