Pine Script from scratch: indicators and strategies on TradingView.

If Python is the gateway to exchange bots, Pine Script is the gateway to chart automation. It's TradingView's native language, designed specifically for technical analysis, and it has a huge advantage for beginners: you program, plot and backtest on the same screen, with nothing to install. This tutorial uses the current version, Pine Script v5.

01What Pine Script is (and why to start with it)

Pine Script is a scripting language created by TradingView for two purposes: building custom indicators (which plot on the chart) and building strategies (which generate buy/sell signals and can be tested on history). It's simple, specific and runs in TradingView's cloud — you don't need a server or any installation.

02Your first indicator

In TradingView, open the Pine Editor (tab at the bottom of the chart). Every script begins by declaring the version and type. Let's plot a simple moving average:

//@version=5
indicator("My First MA", overlay=true)

// input: makes the period adjustable from the interface
period = input.int(20, "MA Period")

// compute the simple moving average of the close
ma = ta.sma(close, period)

// plot it on the chart
plot(ma, "MA", color=color.aqua, linewidth=2)

Click Add to chart. Done — your average appears over the candles. The overlay=true is what makes the indicator draw on top of price (instead of in a separate panel below).

03The concepts you need to understand

The time series

In Pine, variables like close, open, high, low aren't a single number — they're series. The script runs once for each candle on the chart, and close always refers to the current candle's close on that pass. To access earlier candles, use brackets: close[1] is the previous candle's close, close[2] the one two bars back.

The ta library functions

The ta (technical analysis) library has everything ready: ta.sma() (simple average), ta.ema() (exponential), ta.rsi(), ta.macd(), ta.crossover() (cross up), ta.crossunder() (cross down). You rarely need to compute an indicator by hand.

04From indicator to strategy

The crucial difference: indicator() only draws; strategy() simulates trades and generates a backtest report. Let's turn the average into a crossover system that trades:

//@version=5
strategy("Moving Average Crossover", overlay=true,
         initial_capital=10000, default_qty_type=strategy.percent_of_equity,
         default_qty_value=10)

// adjustable parameters
fast = input.int(9,  "Fast MA")
slow = input.int(21, "Slow MA")

fast_ma = ta.ema(close, fast)
slow_ma = ta.ema(close, slow)

// detect the crossovers
crossUp   = ta.crossover(fast_ma, slow_ma)
crossDown = ta.crossunder(fast_ma, slow_ma)

// trading rules
if crossUp
    strategy.entry("Buy", strategy.long)
if crossDown
    strategy.close("Buy")

// visualize the averages
plot(fast_ma, "Fast", color=color.lime)
plot(slow_ma, "Slow", color=color.orange)

When you add it to the chart, TradingView automatically opens the Strategy Tester below — with net profit, number of trades, win rate, maximum drawdown and the equity curve. You just ran a backtest without writing a single line of test code.

05Adding stop loss and take profit

A strategy without risk management is incomplete. In Pine, you define the stop and target at the moment of entry:

// inside the entry block
if crossUp
    strategy.entry("Buy", strategy.long)
    // stop 2% below, target 4% above (risk:reward 1:2)
    strategy.exit("Exit", "Buy",
                   stop  = close * 0.98,
                   limit = close * 1.04)

06Alerts: the bridge to automation

Pine Script runs on TradingView and doesn't execute orders at your broker on its own. The bridge to automation is alerts. You add an alert in the code, and when the condition fires, TradingView can send a webhook (an HTTP request) to a server that executes the order at the broker.

// fire an alert on the crossover
if crossUp
    alert("BUY BTCUSDT", alert.freq_once_per_bar_close)
if crossDown
    alert("SELL BTCUSDT", alert.freq_once_per_bar_close)

Two ways to turn the alert into a real order: (1) native integration — brokers that support TradingView (like Pepperstone) execute directly from the chart; (2) webhook + server — the alert calls your server (e.g. a Python script that receives the webhook and sends the order via API, as we show in the Binance tutorial).

07Next steps to master it

• Study the whole ta library — RSI, MACD, Bollinger, ATR. Each one opens up new strategies.
• Learn arrays and var to keep state between candles (e.g. tracking a support level).
• Detect SMC patterns — order blocks and fair value gaps can be coded in Pine (see our Smart Money Concepts guide).
• Read the official Pine v5 manual — it's the best reference and has examples for everything.

08Frequently asked questions