Pine Script Tutorial for Beginners: Build Your First TradingView Indicator (2026)

Affiliate Disclosure: This article contains affiliate links. If you sign up for TradingView through our link, we may earn a commission at no extra cost to you. We only recommend platforms we genuinely believe in.

This pine script tutorial for beginners is written for traders — not software developers. If you have spent any time on TradingView, you have almost certainly used indicators built by other people. Pine Script is what gives you the ability to build your own. That is a meaningful shift, and it is more accessible than most traders assume.

Pine Script is TradingView’s proprietary scripting language. It runs entirely in the cloud, directly on your charts, without any software installation or local setup. You write code in the built-in Pine Editor, click a button, and your indicator appears on the chart immediately. For traders who want more than the standard toolkit offers, this is the most practical entry point available.

This guide covers Pine Script v6, the current version as of 2026. Everything here is written to be understood by someone with no coding background, but with enough trading experience to know what they actually want to measure.

What Pine Script Actually Is (And What It Is Not)

Pine Script is a domain-specific language. That means it was built for one purpose: creating trading indicators and strategies on TradingView. It is not Python. It is not JavaScript. It does not run outside of TradingView, and it was never designed to.

That constraint is actually a feature. Because Pine Script has a narrow purpose, it is far simpler than general-purpose programming languages. You do not need to understand memory management, data structures, or object-oriented programming. You need to understand price data, bar logic, and what you want to visualise on a chart.

Pine Script executes once per bar on historical data, and then continues to execute in real time as new price data arrives. Every built-in variable — close, open, high, low, volume — is automatically a series of values tied to each bar. This is different from how most programming languages work, but it maps naturally to how traders think about price.

The TradingView community has published more than 150,000 scripts written in Pine Script. Many of the platform’s own built-in indicators — RSI, MACD, Bollinger Bands — are written in Pine Script themselves. That tells you something about how capable the language actually is.

Why Traders Learn Pine Script

The honest answer is control. Standard indicators are built for the broadest possible audience. They use default settings and standard formulas because those defaults work reasonably well across most markets and timeframes. But markets are not uniform, and the parameters that work well for Bitcoin on a four-hour chart are not necessarily the right parameters for S&P 500 futures on a fifteen-minute chart.

Pine Script lets you modify those parameters precisely, or build entirely new indicators that reflect how you personally think about price action. A trader who focuses on volatility breakouts, for example, can build a custom volatility channel that fits their exact methodology rather than adapting their approach to fit a generic tool.

Beyond indicators, Pine Script also powers strategy backtesting. You can codify an entry and exit ruleset, run it across years of historical data, and see exactly how it would have performed — including drawdowns, win rate, and risk-adjusted returns. That is a significant analytical capability that no amount of manual chart reading can replicate.

The third use case is alerts. You can write conditions in Pine Script and attach TradingView alerts to them, so you are notified the moment a specific price pattern or indicator condition occurs — across any market, any timeframe, without watching the screen.

Understanding Pine Script v6

Pine Script v6 is the current and actively maintained version of the language. TradingView has been explicit that future updates will apply exclusively to v6, so if you are starting from scratch, there is no reason to learn an older version. Build good habits with v6 syntax from the beginning.

The key improvements in v6 over earlier versions include stricter type handling, improved boolean logic, better error messaging, and the introduction of the bid and ask built-in variables for real-time market data. For beginners, most of these changes are invisible — you simply write cleaner, more predictable code. For intermediate users, they reduce debugging time considerably.

One practically useful addition in v6 is the Pine Profiler. This tool analyses your script’s performance and shows you where it is spending computational time. At the beginner level, you will not need it. But it is good to know it exists when your scripts become more complex.

The Pine Editor itself has also been updated in 2026 — it now opens in a side panel rather than at the bottom of the screen. This is a genuinely useful change because you can edit your code and watch the chart respond at the same time, without the editor taking up half your screen.

Setting Up the Pine Editor

You do not need a paid TradingView account to start writing Pine Script. A free account is sufficient to open the Pine Editor, write indicators, and apply them to your charts. Some advanced features — publishing scripts publicly, using certain data feeds, running more complex backtests — require a paid plan, but the core scripting environment is available to all users.

To open the Pine Editor, log in to TradingView and open any chart. In the updated 2026 interface, look for the Pine Editor option in the right-side panel or access it through the bottom toolbar. Click the icon and the editor will open alongside your chart in split-view mode on wider screens.

When you first open it, you will see a default script — usually a simple indicator template with a few lines of code already populated. You can either modify this template or click New to start with a completely blank script. For this pine script tutorial, we will build from scratch so every line is intentional and understood.

The Structure of Every Pine Script Tutorial

Every Pine Script follows the same basic structure. Before writing any logic, you need to declare the version and define what kind of script you are building. Here is what the opening of any v6 indicator looks like:

//@version=6
indicator("My First Indicator", overlay=true)

The first line tells TradingView which version of Pine Script you are using. This is mandatory. The second line declares the script as an indicator and gives it a name. The overlay=true argument tells TradingView to display this indicator directly on the price chart rather than in a separate panel below.

If you are building an indicator that does not belong on the price chart — an oscillator like RSI, for example — you would use overlay=false instead. The indicator would then appear in its own panel beneath the chart.

These two lines are the foundation of every indicator script. Learn them once and they apply to everything you build.

Core Concepts You Need to Understand

Series Data

The most important concept in Pine Script is the series. Every built-in price variable — close, open, high, low, volume — is not a single number. It is a series of values, one for each bar on your chart. When you write close in Pine Script, you are referencing the closing price of the current bar. When you write close[1], you are referencing the closing price of the previous bar. This square bracket notation is how you look back through history.

This might seem like a small technical detail, but it is actually the mental model that makes Pine Script click for traders. You are always working with a sequence of bars, and the language is built around that assumption. Once you internalise it, reading Pine Script becomes straightforward.

Variables

Variables in Pine Script store values. You declare them using the var keyword for values that persist across bars, or simply by assigning a value directly for single-bar calculations. Here is a simple example:

myClose = close
myPreviousClose = close[1]

You can then use these named variables anywhere in your script. Naming values this way makes your code easier to read and easier to modify later.

Built-In Functions

Pine Script includes a large library of built-in functions that handle common trading calculations. Rather than writing the mathematics for a simple moving average from scratch, you call ta.sma(). Rather than calculating RSI manually, you call ta.rsi(). This is where the language’s trader-first design becomes apparent — the functions you actually need are already there.

The ta prefix stands for technical analysis. Most of the indicator calculations you would want to use are available under this namespace. The full list is in TradingView’s official Pine Script v6 reference manual, which is worth bookmarking.

The plot() Function

The plot() function is how you display values on your chart. Without a plot() call, your script runs its calculations but shows nothing. At its simplest:

plot(close)

This plots the closing price as a line on your chart. You can customise the colour, line width, style, and title. Here is a slightly more complete version:

plot(close, title="Close Price", color=color.blue, linewidth=2)

Most of the indicators you build will end with one or more plot() calls. Get comfortable with this function early — you will use it constantly.

Building Your First Indicator: A Simple Moving Average

The most practical way to learn Pine Script is to build something real. A simple moving average is the ideal starting point — it is genuinely useful, the logic is easy to follow, and it introduces every core concept you need without overwhelming complexity.

Here is the complete script:

//@version=6
indicator("Simple Moving Average", overlay=true)

length = input.int(20, title="SMA Length", minval=1)
smaValue = ta.sma(close, length)

plot(smaValue, title="SMA", color=color.orange, linewidth=2)

Let us walk through every line.

The version declaration and indicator() call are the standard opening we covered earlier. The overlay=true argument places this indicator directly on the price chart, which is correct for a moving average.

The input.int() function creates a user-adjustable input. This means that when you apply this indicator to a chart, TradingView will display a settings panel where you can change the period from 20 to any value you choose — without touching the code. The title parameter labels it clearly. The minval=1 prevents someone from entering zero or a negative number, which would cause an error.

The ta.sma() function calculates the simple moving average. It takes two arguments: the series to calculate on (close) and the period length (length, which we defined with input.int above). The result is stored in a variable called smaValue.

Finally, plot() draws the moving average on the chart as an orange line with a width of 2. Paste this into your Pine Editor, click Add to Chart, and you will see a clean, configurable moving average appear immediately.

That is a complete, functional, deployable indicator — written in six lines of code.

Adding a Second Moving Average and a Crossover Signal

Now that you have a working indicator, let us extend it. A single moving average tells you about trend direction. Two moving averages — one short, one long — let you identify crossovers, which many traders use as entry signals. Here is the expanded version:

//@version=6
indicator("Moving Average Crossover", overlay=true)

fastLength = input.int(9, title="Fast SMA", minval=1)
slowLength = input.int(21, title="Slow SMA", minval=1)

fastSMA = ta.sma(close, fastLength)
slowSMA = ta.sma(close, slowLength)

plot(fastSMA, title="Fast SMA", color=color.blue, linewidth=2)
plot(slowSMA, title="Slow SMA", color=color.red, linewidth=2)

bullCross = ta.crossover(fastSMA, slowSMA)
bearCross = ta.crossunder(fastSMA, slowSMA)

plotshape(bullCross, title="Bullish Cross", location=location.belowbar, color=color.green, style=shape.triangleup, size=size.small)
plotshape(bearCross, title="Bearish Cross", location=location.abovebar, color=color.red, style=shape.triangledown, size=size.small)

This script introduces two new functions worth understanding. ta.crossover() returns true on the bar where the first series crosses above the second series. ta.crossunder() does the opposite. Both return a boolean value — true or false — on each bar.

The plotshape() function draws visual markers on the chart when the condition is true. In this case, a green upward triangle appears below the bar when the fast SMA crosses above the slow SMA, and a red downward triangle appears above the bar on a bearish cross.

This is now a genuinely useful tool — a customisable dual moving average crossover system with visual signals, built in under twenty lines of code.

Adding Alerts to Your Pine Script Indicator

Visual signals on a chart are useful. Alerts that notify you when a condition occurs — without you watching the screen — are more useful. Pine Script lets you attach alert conditions to any boolean expression in your indicator.

Add these two lines to the moving average crossover script above:

alertcondition(bullCross, title="Bullish Crossover", message="Fast SMA crossed above Slow SMA")
alertcondition(bearCross, title="Bearish Crossover", message="Fast SMA crossed below Slow SMA")

Once you add the indicator to your chart, go to the TradingView alerts panel, create a new alert, and select your indicator from the dropdown. The alert conditions you defined in Pine Script will appear as options. Set your preferred notification method — email, mobile push, or webhook — and you will be notified the next time either crossover occurs, on any market, on any timeframe.

This combination of Pine Script and TradingView’s alert system is one of the most practical tools available to independent traders who cannot monitor screens continuously. Alerts on paid TradingView plans can fire across multiple tickers simultaneously, which multiplies the utility considerably. If you are not yet on a paid plan, this is one of the most concrete reasons to consider upgrading.

You can explore TradingView’s plan options at TradingView — the paid tiers unlock more simultaneous alerts, more indicators per chart, and additional data access that becomes relevant as your scripts grow in complexity.

Understanding Input Types

Inputs are what make your indicators reusable rather than hardcoded. Pine Script v6 supports several input types, each suited to a different kind of parameter.

input.int() accepts whole numbers — useful for periods, lengths, and lookback windows. input.float() accepts decimal numbers — useful for thresholds, multipliers, and percentage values. input.bool() creates a true/false toggle — useful for turning features of your indicator on or off. input.color() lets the user choose a colour from a colour picker. input.source() lets the user choose which price series to calculate on — close, open, high, low, hl2, and so on.

Here is an example combining several input types:

//@version=6
indicator("Configurable SMA", overlay=true)

src = input.source(close, title="Source")
length = input.int(20, title="Length", minval=1)
lineColor = input.color(color.blue, title="Line Color")
showSMA = input.bool(true, title="Show SMA")

smaValue = ta.sma(src, length)

plot(showSMA ? smaValue : na, title="SMA", color=lineColor, linewidth=2)

Notice the conditional in the final plot() call. The expression showSMA ? smaValue : na means: if showSMA is true, plot the SMA value; if it is false, plot nothing (na means not available — Pine Script’s equivalent of a null or empty value). This pattern is extremely common and worth memorising.

Conditional Logic in Pine Script

Most useful indicators require conditional logic — the ability to evaluate different outcomes based on whether a condition is true or false. Pine Script handles this with standard if/else blocks and with the ternary operator shown above.

Here is a practical example. Suppose you want to colour your moving average green when price is above it and red when price is below it:

//@version=6
indicator("Coloured SMA", overlay=true)

length = input.int(20, title="SMA Length", minval=1)
smaValue = ta.sma(close, length)

smaColor = close > smaValue ? color.green : color.red

plot(smaValue, title="SMA", color=smaColor, linewidth=2)

The ternary expression evaluates close > smaValue. If true, smaColor is green. If false, it is red. This changes on every bar, so the moving average line dynamically shifts colour as price crosses it. This is a small addition that makes the indicator significantly more readable at a glance.

Common Mistakes Beginners Make

The first and most common mistake is forgetting the version declaration. Without //@version=6 at the top of your script, TradingView will attempt to run it as an older version of Pine Script and may produce unexpected errors or warnings.

The second mistake is confusing series values with single values. If you try to use a series variable in a context that expects a single number — for example, as a fixed reference level — Pine Script will throw an error. Understanding that most variables in Pine Script are series, not scalars, prevents a large category of confusion.

The third mistake is over-fitting during backtesting. This applies less to Pine Script as a language and more to how traders use it. When you run a strategy on historical data and adjust parameters until the results look excellent, you are likely fitting your strategy to noise rather than discovering a genuine edge. The right approach is to define your parameters before looking at the results, then test against out-of-sample data.

The fourth mistake is ignoring the reference manual. When something is not working, the Pine Script v6 reference manual should be your first stop. The error messages in Pine Script v6 have also been improved — they are more descriptive than earlier versions and usually point directly to the problem.

What You Can Build Beyond Indicators

Everything covered in this tutorial applies to indicators — scripts that calculate and display values on a chart without placing trades. Pine Script also supports two other script types that open up further capabilities.

Strategy scripts use the same syntax but add the ability to define entry and exit rules, then run them against historical data using TradingView’s Strategy Tester. The output includes a full performance report — total return, maximum drawdown, Sharpe ratio, win rate, and a trade-by-trade breakdown. For traders who want to validate ideas before trading them live, this is an extremely valuable tool.

Library scripts allow you to package reusable functions and share them with other Pine Script users. These are more relevant at an intermediate or advanced level, but they represent the social dimension of Pine Script — the same reason there are 150,000 community scripts available on TradingView. The ecosystem is collaborative, and open-source scripts are a legitimate way to accelerate your own learning.

Which TradingView Plan Do You Need for Pine Script?

As noted earlier, the Pine Editor is available on all TradingView plans including the free tier. You can write, test, and apply custom indicators without paying anything. However, several features relevant to serious Pine Script users are restricted to paid plans.

The number of indicators you can add to a single chart increases with each plan tier. On the free plan, you are limited to a small number of indicators per chart — which matters if you are running multiple custom scripts simultaneously. Paid plans also allow more concurrent alerts, which is where Pine Script’s alert functionality becomes most powerful. Advanced data access, including certain higher-resolution timeframes and premium data feeds, is also gated behind paid subscriptions.

For traders who are just learning Pine Script, the free plan is genuinely sufficient. As your scripts become more sophisticated and your use cases more demanding, the paid tiers become worth evaluating. TradingView’s own pricing page details exactly what each plan includes — it is worth reading carefully against your specific workflow before upgrading.

If you are ready to explore what a paid plan unlocks, you can start a free trial through our TradingView affiliate link.

Where to Go Next

This pine script tutorial has given you a working foundation — the structure of Pine Script v6, core data concepts, built-in functions, input handling, conditional logic, and two complete indicators you can deploy immediately. The logical next steps depend on where you want to take it.

If you want to deepen your understanding of the language, TradingView’s official Pine Script v6 User Manual is the best single resource. It is thorough, well-maintained, and updated as new features are released. Read the sections on series, built-in variables, and the ta namespace in detail.

If you want to learn by reading real code, browse the TradingView community scripts library and look specifically for scripts labelled as open-source. The Editor’s Picks section contains code written by experienced Pine Script developers — studying it will teach you patterns and techniques that no tutorial covers explicitly.

If you want to explore what TradingView’s charting platform can do beyond Pine Script, our TradingView review covers the platform in full. For traders focused specifically on crypto, the guide to using TradingView for crypto trading is a practical companion to what you have just learned. And if you want to understand which indicators are worth building on top of, the breakdown of the best TradingView indicators for crypto gives you a clear starting point.

Pine Script rewards patience. The first indicator you build will take longer than the tenth. But the compounding effect of being able to build your own tools — rather than adapting your trading to someone else’s — is worth the initial investment of time.