Skip to main content

Publishing and Sharing Scripts 📢

Publishing your Pine Script on TradingView transforms a personal tool into a resource that can help thousands of traders, build your reputation, and even generate income. This chapter covers everything you need to know: documenting your code properly, choosing the right protection level, writing descriptions that pass moderation, distributing scripts publicly or privately, managing versions, monetizing your work, and engaging with the community.

Script Documentation​

Good documentation is the difference between a script that gains traction and one that gets ignored. TradingView moderators check documentation quality before featuring scripts, and users rely on it to decide whether to add your indicator to their charts.

Header Documentation​

Every published script should begin with a structured metadata header. This header tells other developers (and your future self) what the script does, who wrote it, and what version it is. Pine Script supports @description, @author, and @version annotations inside comments.

//@version=5
// @description    Multi-Timeframe Trend Dashboard — displays trend direction
//                 across multiple timeframes using EMA crossovers.
// @author         YourTradingViewUsername
// @version        2.1.0
// @license        Mozilla Public License 2.0
//
// @changelog
// v2.1.0 - Added weekly timeframe support
// v2.0.0 - Refactored to Pine Script v5, new input system
// v1.0.0 - Initial release with daily and 4H timeframes

indicator("Multi-TF Trend Dashboard", overlay=false)

// --- Inputs with descriptive tooltips ---
fastLength = input.int(9, "Fast EMA Length", minval=1,
    tooltip="Period for the fast Exponential Moving Average. Lower values react faster to price changes.")
slowLength = input.int(21, "Slow EMA Length", minval=1,
    tooltip="Period for the slow Exponential Moving Average. Higher values smooth out noise.")
showWeekly = input.bool(true, "Show Weekly Timeframe",
    tooltip="Enable or disable the weekly trend row in the dashboard.")

// --- Core calculations ---
fastEMA = ta.ema(close, fastLength)
slowEMA = ta.ema(close, slowLength)
trendUp = fastEMA > slowEMA

// --- Visualization ---
plotColor = trendUp ? color.green : color.red
plot(trendUp ? 1 : -1, "Current TF Trend", color=plotColor, style=plot.style_columns)

The tooltip parameter on each input is especially important. When a user hovers over a parameter in the TradingView settings panel, the tooltip text appears, explaining exactly what that setting controls without the user needing to read your source code.

Code Comments and Function Docs​

For scripts that contain custom functions, use @function, @param, and @returns annotations. These follow the same convention used in Pine Script libraries and make your code self-documenting.

//@version=5
// @description    Utility library for risk-based position sizing and
//                 signal quality scoring.
// @author         YourTradingViewUsername
// @version        1.0.0

indicator("Documented Functions Example", overlay=true)

//@function    Calculates position size based on account risk and stop distance.
//@param       accountEquity  The current account equity in base currency.
//@param       riskPercent    Maximum percentage of equity to risk (e.g. 1.0 for 1%).
//@param       entryPrice     Planned entry price for the trade.
//@param       stopPrice      Planned stop-loss price for the trade.
//@returns     float          The number of units/shares to purchase.
calcPositionSize(float accountEquity, float riskPercent, float entryPrice, float stopPrice) =>
    float riskAmount = accountEquity * (riskPercent / 100.0)
    float stopDistance = math.abs(entryPrice - stopPrice)
    float rawSize = stopDistance > 0 ? riskAmount / stopDistance : 0.0
    // Cap position size so it never exceeds full equity
    math.min(rawSize, accountEquity / entryPrice)

//@function    Scores signal quality from 0 to 100 based on RSI and volume.
//@param       rsiValue       Current RSI reading (0-100).
//@param       volRatio       Current volume divided by its 20-bar average.
//@returns     float          Quality score between 0 and 100.
scoreSignal(float rsiValue, float volRatio) =>
    // RSI component: strongest when RSI is between 30-70 (trending, not extreme)
    float rsiScore = rsiValue >= 30 and rsiValue <= 70 ? 50.0 : 25.0
    // Volume component: higher volume confirms the signal
    float volScore = math.min(volRatio * 25.0, 50.0)
    rsiScore + volScore

// --- Usage ---
equity = 100000.0
entry = close
stop = close - ta.atr(14) * 2
posSize = calcPositionSize(equity, 1.0, entry, stop)

rsiVal = ta.rsi(close, 14)
volAvg = ta.sma(volume, 20)
volRatio = volAvg > 0 ? volume / volAvg : 0.0
quality = scoreSignal(rsiVal, volRatio)

plot(quality, "Signal Quality", color=color.orange)

Follow these inline documentation best practices:

  • Comment the why, not the what. // Cap at equity is less useful than // Prevent position from exceeding available capital.
  • Group related code with section headers using // --- Section Name ---.
  • Keep comments concise and on the line above or beside the relevant code.

TradingView's Script Protection Options​

When you publish a script on TradingView, you choose one of three protection levels. Understanding these is critical because you cannot change the protection level after publishing.

Open Source -- Your full source code is visible to everyone. Any user can read, learn from, and fork your code. This is the best option for educational scripts, community contributions, and building reputation. TradingView moderators are more likely to feature open-source scripts.

Protected -- Users can add the script to their charts and use it freely, but the source code is hidden. TradingView compiles and stores your code server-side; no one can view it. Use this when you want broad free distribution but want to keep your methodology private.

Invite-Only -- The source code is hidden, and only users you explicitly grant access can use the script. This is the foundation for paid/premium script distribution. You manage access through TradingView's built-in invite system.

How to choose:

  • Building reputation and followers? Publish Open Source.
  • Sharing a unique indicator freely but protecting IP? Use Protected.
  • Selling access or running a subscription service? Use Invite-Only.

There is no way to "obfuscate" Pine Script code within the script itself. Source protection is handled entirely by TradingView's publishing settings. Do not attempt workarounds like renaming variables to random strings -- this violates TradingView's house rules and makes your code unmaintainable.

Writing Effective Script Descriptions​

Your script description is what TradingView moderators evaluate and what users read before deciding to use your script. A poor description can get your script rejected or ignored.

What TradingView Moderators Look For​

  • A clear explanation of what the indicator/strategy does
  • Instructions on how to use it
  • A description of all inputs and what they control
  • At least one chart screenshot showing the script in action
  • Original content (not a duplicate of an existing public script)

Required Elements​

Every script description should contain these sections:

  1. Title and summary -- One or two sentences explaining the purpose.
  2. How It Works -- The methodology or logic behind the script.
  3. How To Use -- Step-by-step instructions for adding and configuring.
  4. Inputs Explained -- A list of every input with its purpose and recommended values.
  5. Screenshots -- Annotated chart images showing the script in action.

Description Template​

TradingView descriptions support basic Markdown. Here is a complete template:

📊 **Multi-Timeframe Trend Dashboard**

This indicator displays trend direction across multiple timeframes
using EMA crossovers, helping you align your trades with the
dominant trend.

**🔍 How It Works**
The script calculates fast and slow EMAs on the current chart
timeframe plus the daily and weekly timeframes. A green column
means the fast EMA is above the slow EMA (bullish); red means
bearish.

**📖 How To Use**
1. Add the indicator to your chart.
2. Adjust the Fast EMA and Slow EMA lengths in Settings.
3. Enable or disable the Weekly timeframe row as needed.
4. Look for all timeframes to align before entering a trade.

**⚙️ Inputs**
- Fast EMA Length (default: 9) — Period for the fast EMA.
- Slow EMA Length (default: 21) — Period for the slow EMA.
- Show Weekly (default: true) — Toggle weekly timeframe display.

**📸 Screenshots**
(Attach annotated screenshots showing bullish and bearish examples)

**⚠️ Disclaimer**
This script is for educational purposes only. It does not
constitute financial advice. Always do your own research.

Screenshot Best Practices​

  • Use a clean chart with the script applied and no clutter.
  • Annotate key signals with TradingView's drawing tools.
  • Show at least one bullish and one bearish example.
  • Use a white or dark background consistently.

Script Distribution​

Public Publishing​

Public scripts appear in TradingView's script library and can be found through search. To maximize discoverability, use relevant metadata tags and follow TradingView's publishing guidelines.

Publishing guidelines and rules:

  • The script must add genuine value (not a trivial moving average with no twist).
  • The title must accurately describe the script's function.
  • You must not republish the same script repeatedly.
  • Descriptions must be in English (you can add other languages below).

Here is an indicator structured and ready for public publishing:

//@version=5
// @description    Momentum Divergence Detector — identifies bullish and bearish
//                 divergences between price and RSI, with customizable lookback.
// @author         YourTradingViewUsername
// @version        1.0.0
// @tags           momentum, divergence, RSI, trend reversal

indicator("Momentum Divergence Detector", overlay=true, max_labels_count=50)

// --- Inputs ---
rsiLength = input.int(14, "RSI Length", minval=2,
    tooltip="Period for the RSI calculation.")
lookback = input.int(5, "Pivot Lookback", minval=1,
    tooltip="Number of bars to the left and right for detecting pivots.")
showBull = input.bool(true, "Show Bullish Divergences",
    tooltip="Plot labels where bullish divergences are detected.")
showBear = input.bool(true, "Show Bearish Divergences",
    tooltip="Plot labels where bearish divergences are detected.")

// --- RSI calculation ---
rsiValue = ta.rsi(close, rsiLength)

// --- Pivot detection ---
pivotLow = ta.pivotlow(low, lookback, lookback)
pivotHigh = ta.pivothigh(high, lookback, lookback)

// --- Bullish divergence: price makes lower low, RSI makes higher low ---
var float prevPriceLow = na
var float prevRsiLow = na

if not na(pivotLow)
    float currentRsiLow = ta.rsi(close, rsiLength)[lookback]
    if not na(prevPriceLow)
        bool priceLowerLow = pivotLow < prevPriceLow
        bool rsiHigherLow = currentRsiLow > prevRsiLow
        if priceLowerLow and rsiHigherLow and showBull
            label.new(bar_index - lookback, low[lookback], "Bull Div",
                color=color.green, textcolor=color.white,
                style=label.style_label_up, size=size.small)
    prevPriceLow := pivotLow
    prevRsiLow := currentRsiLow

// --- Bearish divergence: price makes higher high, RSI makes lower high ---
var float prevPriceHigh = na
var float prevRsiHigh = na

if not na(pivotHigh)
    float currentRsiHigh = ta.rsi(close, rsiLength)[lookback]
    if not na(prevPriceHigh)
        bool priceHigherHigh = pivotHigh > prevPriceHigh
        bool rsiLowerHigh = currentRsiHigh < prevRsiHigh
        if priceHigherHigh and rsiLowerHigh and showBear
            label.new(bar_index - lookback, high[lookback], "Bear Div",
                color=color.red, textcolor=color.white,
                style=label.style_label_down, size=size.small)
    prevPriceHigh := pivotHigh
    prevRsiHigh := currentRsiHigh

This script is self-contained, well-documented, and addresses a genuine trading need. The tags in the header comment help you remember which category tags to select when publishing through TradingView's UI.

Invite-Only Distribution​

Invite-only scripts let you control exactly who has access. After publishing as invite-only, you manage users through TradingView's "Manage Access" panel on the script's page. You can add users by their TradingView username, and remove them at any time.

A common pattern is offering a free tier with basic features and a premium tier with advanced features, controlled by input.bool() toggles. The author publishes two versions (or one version with a toggle that only premium users are instructed to enable):

//@version=5
// @description    Trend Suite — Basic and Premium feature tiers.
//                 Basic: EMA crossover signals.
//                 Premium: Bollinger Band squeeze detection + signal quality filter.
// @author         YourTradingViewUsername
// @version        2.0.0

indicator("Trend Suite", overlay=true)

// --- Tier Selection ---
isPremium = input.bool(false, "Enable Premium Features",
    tooltip="Premium features include Bollinger Band squeeze detection and signal quality filtering. Contact the author for premium access.")

// --- Shared Inputs ---
fastLen = input.int(9, "Fast EMA", minval=1)
slowLen = input.int(21, "Slow EMA", minval=1)

// --- Basic Features (available to all users) ---
fastEMA = ta.ema(close, fastLen)
slowEMA = ta.ema(close, slowLen)

bullishCross = ta.crossover(fastEMA, slowEMA)
bearishCross = ta.crossunder(fastEMA, slowEMA)

plot(fastEMA, "Fast EMA", color=color.blue, linewidth=1)
plot(slowEMA, "Slow EMA", color=color.orange, linewidth=1)

plotshape(bullishCross, "Buy", shape.triangleup,
    location.belowbar, color.green, size=size.small)
plotshape(bearishCross, "Sell", shape.triangledown,
    location.abovebar, color.red, size=size.small)

// --- Premium Features ---
if isPremium
    // Bollinger Band squeeze detection using ta.bb()
    [bbMiddle, bbUpper, bbLower] = ta.bb(close, 20, 2.0)
    float bbWidth = bbUpper - bbLower
    float bbWidthAvg = ta.sma(bbWidth, 50)
    bool isSqueeze = bbWidth < bbWidthAvg * 0.75

    // Signal quality filter: only show signals during high-volume bars
    float volSma = ta.sma(volume, 20)
    bool highVolume = volume > volSma * 1.2

    // Premium visual: highlight squeeze zones
    bgcolor(isSqueeze ? color.new(color.yellow, 85) : na)

    // Premium labels: filtered high-quality signals
    bool premiumBuy = bullishCross and highVolume and not isSqueeze
    bool premiumSell = bearishCross and highVolume and not isSqueeze

    if premiumBuy
        label.new(bar_index, low, "HQ Buy",
            color=color.green, textcolor=color.white,
            style=label.style_label_up, size=size.small)
    if premiumSell
        label.new(bar_index, high, "HQ Sell",
            color=color.red, textcolor=color.white,
            style=label.style_label_down, size=size.small)

In this pattern, the basic EMA crossover signals are visible to everyone. Premium users who enable the toggle get Bollinger Band squeeze detection and volume-filtered "high quality" signals. The author publishes the script as invite-only and instructs premium subscribers to enable the toggle.

Version Control​

Change Management​

Pine Script does not have built-in version control, but you can implement a disciplined versioning system using comments and a version string. Use semantic versioning: MAJOR.MINOR.PATCH.

  • MAJOR: Breaking changes (renamed inputs, removed features, changed default behavior).
  • MINOR: New features that are backward-compatible.
  • PATCH: Bug fixes and minor tweaks.
//@version=5
// @description    RSI Trend Filter with version tracking.
// @author         YourTradingViewUsername
// @version        2.3.1
//
// @changelog
// v2.3.1 [2025-12-15] - Fixed ATR multiplier not applying to short signals
// v2.3.0 [2025-12-01] - Added ATR-based stop loss visualization
// v2.2.0 [2025-11-15] - Added divergence detection mode
// v2.1.0 [2025-10-20] - Added multi-timeframe RSI option
// v2.0.0 [2025-09-01] - BREAKING: Migrated to Pine Script v5, new input names
// v1.0.0 [2025-06-01] - Initial release

indicator("RSI Trend Filter v2.3.1", overlay=false)

// --- Version display ---
VERSION = "2.3.1"

// --- Inputs ---
rsiLen = input.int(14, "RSI Length", minval=2,
    tooltip="Period for RSI calculation.")
overbought = input.int(70, "Overbought Level", minval=50, maxval=100,
    tooltip="RSI level considered overbought.")
oversold = input.int(30, "Oversold Level", minval=0, maxval=50,
    tooltip="RSI level considered oversold.")
showVersion = input.bool(true, "Show Version Label",
    tooltip="Display the current script version on the chart.")

// --- Calculations ---
rsiVal = ta.rsi(close, rsiLen)
isOverbought = rsiVal >= overbought
isOversold = rsiVal <= oversold

// --- Plotting ---
plot(rsiVal, "RSI", color=color.purple, linewidth=2)
hline(overbought, "Overbought", color=color.red, linestyle=hline.style_dashed)
hline(oversold, "Oversold", color=color.green, linestyle=hline.style_dashed)

bgcolor(isOverbought ? color.new(color.red, 90) : isOversold ? color.new(color.green, 90) : na)

// --- Version label on last bar ---
if barstate.islast and showVersion
    label.new(bar_index, rsiVal, "v" + VERSION,
        color=color.gray, textcolor=color.white,
        style=label.style_label_left, size=size.small)

Backward Compatibility​

When you release a major update that changes behavior, give users a way to keep the old behavior. This prevents frustration and negative feedback. A simple approach is an input.string() dropdown that selects between calculation methods:

//@version=5
// @description    Moving Average Crossover with backward-compatible modes.
// @author         YourTradingViewUsername
// @version        3.0.0
//
// @changelog
// v3.0.0 - New default uses VWMA; legacy SMA mode preserved
// v2.0.0 - Added EMA option
// v1.0.0 - Original SMA crossover

indicator("MA Crossover v3", overlay=true)

// --- Version mode selector ---
calcMode = input.string("VWMA (v3.0)", "Calculation Mode",
    options=["SMA (v1.0)", "EMA (v2.0)", "VWMA (v3.0)"],
    tooltip="Select which moving average method to use. Legacy modes preserve behavior from older versions.")

fastLen = input.int(9, "Fast Length", minval=1)
slowLen = input.int(21, "Slow Length", minval=1)

// --- Calculate based on selected mode ---
float fastMA = switch calcMode
    "SMA (v1.0)" => ta.sma(close, fastLen)
    "EMA (v2.0)" => ta.ema(close, fastLen)
    "VWMA (v3.0)" => ta.vwma(close, fastLen)
    => ta.vwma(close, fastLen)

float slowMA = switch calcMode
    "SMA (v1.0)" => ta.sma(close, slowLen)
    "EMA (v2.0)" => ta.ema(close, slowLen)
    "VWMA (v3.0)" => ta.vwma(close, slowLen)
    => ta.vwma(close, slowLen)

// --- Signals and plots ---
plot(fastMA, "Fast MA", color=color.blue, linewidth=2)
plot(slowMA, "Slow MA", color=color.orange, linewidth=2)

bullCross = ta.crossover(fastMA, slowMA)
bearCross = ta.crossunder(fastMA, slowMA)

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

When publishing a major update, include migration notes in both the changelog comment and the script description: "If you were using v2.x, select 'EMA (v2.0)' in Calculation Mode to preserve your previous behavior."

Monetization Strategies​

Free with Premium Upsell​

The most effective monetization pattern on TradingView is publishing a genuinely useful free script (open source or protected) that demonstrates your skill, then offering an invite-only premium version with advanced features. The free script acts as marketing for the paid one.

Here is a complete example of a premium indicator that uses Bollinger Bands and ATR for advanced analysis:

//@version=5
// @description    Volatility Analyzer Pro — Premium tier with BB squeeze
//                 scoring and ATR-based target levels.
// @author         YourTradingViewUsername
// @version        1.0.0

indicator("Volatility Analyzer Pro", overlay=true)

// --- Tier control ---
showPremiumTargets = input.bool(false, "Show Premium Price Targets",
    tooltip="Enables ATR-based take-profit and stop-loss levels. Requires premium subscription.")
showSqueezeScore = input.bool(false, "Show Squeeze Score Panel",
    tooltip="Displays a numerical squeeze intensity score. Requires premium subscription.")

// --- Shared Inputs ---
bbLength = input.int(20, "BB Length", minval=5)
bbMult = input.float(2.0, "BB Multiplier", minval=0.5, step=0.1)
atrLength = input.int(14, "ATR Length", minval=1)

// --- Core calculations (free tier) ---
[bbMiddle, bbUpper, bbLower] = ta.bb(close, bbLength, bbMult)
float atrValue = ta.atr(atrLength)

// --- Free tier: Bollinger Band plots ---
plot(bbMiddle, "BB Middle", color=color.gray, linewidth=1)
p1 = plot(bbUpper, "BB Upper", color=color.blue)
p2 = plot(bbLower, "BB Lower", color=color.blue)
fill(p1, p2, color=color.new(color.blue, 92), title="BB Fill")

// --- Premium Feature 1: ATR-based price targets ---
if showPremiumTargets
    float longTarget = close + atrValue * 2.0
    float longStop = close - atrValue * 1.5
    float shortTarget = close - atrValue * 2.0
    float shortStop = close + atrValue * 1.5

    bool nearUpperBand = close > bbUpper - atrValue * 0.25
    bool nearLowerBand = close < bbLower + atrValue * 0.25

    if barstate.islast and nearLowerBand
        label.new(bar_index + 2, longTarget, "TP: " + str.tostring(longTarget, format.mintick),
            color=color.green, textcolor=color.white, style=label.style_label_down)
        label.new(bar_index + 2, longStop, "SL: " + str.tostring(longStop, format.mintick),
            color=color.red, textcolor=color.white, style=label.style_label_up)

    if barstate.islast and nearUpperBand
        label.new(bar_index + 4, shortTarget, "TP: " + str.tostring(shortTarget, format.mintick),
            color=color.green, textcolor=color.white, style=label.style_label_up)
        label.new(bar_index + 4, shortStop, "SL: " + str.tostring(shortStop, format.mintick),
            color=color.red, textcolor=color.white, style=label.style_label_down)

// --- Premium Feature 2: Squeeze intensity score ---
if showSqueezeScore
    float bbWidth = bbUpper - bbLower
    float bbWidthSma = ta.sma(bbWidth, 50)
    float squeezeRatio = bbWidthSma > 0 ? bbWidth / bbWidthSma : 1.0
    // Score: 0 = extreme squeeze, 100 = fully expanded
    float squeezeScore = math.min(squeezeRatio * 100.0, 100.0)

    if barstate.islast
        string scoreText = "Squeeze: " + str.tostring(squeezeScore, "#.0") + "/100"
        color scoreColor = squeezeScore < 50 ? color.orange : color.green
        label.new(bar_index, bbUpper, scoreText,
            color=scoreColor, textcolor=color.white,
            style=label.style_label_down, size=size.normal)

Subscription Models​

For invite-only scripts with monthly or yearly subscriptions:

  1. Set your price -- Research competing scripts in your niche. New authors typically start at $10-30/month. Established authors with proven track records charge $50-200/month.
  2. Manage access -- Use TradingView's Manage Access page to add/remove usernames. For larger subscriber bases, consider building a simple external tool or spreadsheet to track subscription dates.
  3. Payment processing -- TradingView does not handle payments for invite-only scripts. Use external platforms (Gumroad, Patreon, your own website with Stripe) and manually grant access after payment confirmation.
  4. Trial periods -- Offer 7-day free trials by temporarily adding users, then removing access if they do not subscribe.

Marketplace Considerations​

Community scripts vs. paid scripts: TradingView's public library is crowded. Standing out requires genuine quality and originality. Do not publish trivial scripts (a plain RSI plot, for example) and expect them to gain traction.

Building reputation through free scripts: Publish 5-10 high-quality open-source scripts before launching a paid product. This establishes credibility and creates a follower base that you can convert into paying subscribers.

Cross-promotion: In each script's description, link to your other scripts. Use a consistent naming convention (e.g., "YourBrand | Indicator Name") so users recognize your work across the library.

Community Engagement​

Handling User Feedback​

Once your script is published, users will leave comments with questions, bug reports, and feature requests. Responding promptly and professionally builds trust and followers.

Provide configuration presets so users can quickly try recommended setups instead of guessing at input values:

//@version=5
// @description    Adaptive RSI with community-driven configuration presets.
// @author         YourTradingViewUsername
// @version        1.2.0

indicator("Adaptive RSI", overlay=false)

// --- Preset selector based on community feedback ---
preset = input.string("Default", "Configuration Preset",
    options=["Default", "Scalping (1m-5m)", "Swing (1H-4H)", "Position (1D+)"],
    tooltip="Pre-configured settings optimized for different trading styles. These were tuned based on community feedback.")

// --- Determine parameters from preset ---
int rsiLen = switch preset
    "Default"           => 14
    "Scalping (1m-5m)"  => 7
    "Swing (1H-4H)"     => 21
    "Position (1D+)"    => 28
    => 14

int obLevel = switch preset
    "Default"           => 70
    "Scalping (1m-5m)"  => 80
    "Swing (1H-4H)"     => 70
    "Position (1D+)"    => 65
    => 70

int osLevel = switch preset
    "Default"           => 30
    "Scalping (1m-5m)"  => 20
    "Swing (1H-4H)"     => 30
    "Position (1D+)"    => 35
    => 30

// --- Calculations ---
float rsiVal = ta.rsi(close, rsiLen)

// --- Visualization ---
plot(rsiVal, "RSI", color=color.purple, linewidth=2)
hline(obLevel, "Overbought", color=color.red, linestyle=hline.style_dashed)
hline(osLevel, "Oversold", color=color.green, linestyle=hline.style_dashed)

bgcolor(rsiVal >= obLevel ? color.new(color.red, 90) : rsiVal <= osLevel ? color.new(color.green, 90) : na)

// --- Display active preset on chart ---
if barstate.islast
    label.new(bar_index, rsiVal, preset + " | RSI(" + str.tostring(rsiLen) + ")",
        color=color.gray, textcolor=color.white,
        style=label.style_label_left, size=size.small)

Bug report workflow: When a user reports a bug, follow these steps:

  1. Reproduce the issue on your own chart with the same symbol and timeframe.
  2. Check if the issue is related to specific data (thin markets, extended hours, crypto vs. stocks).
  3. Fix and test locally, then update the published script.
  4. Reply to the comment confirming the fix and the new version number.

Building a Script Portfolio​

Branding consistency: Use a consistent prefix or brand name in all script titles (e.g., "AlphaTools | RSI Suite", "AlphaTools | Trend Filter"). This makes your scripts instantly recognizable in search results.

Cross-linking: In every script description, include a section like "Other scripts by this author" with links to your related indicators. Users who like one script are likely to try others.

Growing your follower base: Engage genuinely in TradingView's community. Comment on other authors' scripts with constructive feedback. Answer questions in the Pine Script chat. Publish educational ideas using your scripts. Followers are notified when you publish new scripts, creating a compounding growth effect.

Practice Exercises​

Exercise 1: Write a Complete Script Description

Take one of your existing indicators and write a full description following the template from the "Writing Effective Script Descriptions" section. Include: title and summary, how it works, how to use, inputs explained, and a disclaimer. Publish it as a draft and review how it renders on TradingView.

Exercise 2: Add Tooltips and a Changelog

Take the following skeleton and add (a) meaningful tooltip strings to every input, and (b) a version changelog comment header with at least three version entries:

//@version=5
indicator("EMA Ribbon", overlay=true)

emaCount = input.int(8, "Number of EMAs", minval=2, maxval=10,
    tooltip="How many EMAs to display in the ribbon. More EMAs give finer granularity.")
startLen = input.int(10, "Shortest EMA Length", minval=2,
    tooltip="Period for the shortest (fastest) EMA in the ribbon.")
stepSize = input.int(10, "Step Between EMAs", minval=1,
    tooltip="The difference in period between consecutive EMAs in the ribbon.")
bullColor = input.color(color.green, "Bullish Color",
    tooltip="Color used when the ribbon indicates an uptrend (short EMA above long EMA).")
bearColor = input.color(color.red, "Bearish Color",
    tooltip="Color used when the ribbon indicates a downtrend (short EMA below long EMA).")

float firstEma = ta.ema(close, startLen)
float lastEma = ta.ema(close, startLen + stepSize * (emaCount - 1))
bool isBullish = firstEma > lastEma

plot(firstEma, "Fastest EMA", color=isBullish ? bullColor : bearColor, linewidth=2)
plot(lastEma, "Slowest EMA", color=isBullish ? bullColor : bearColor, linewidth=2)
fill(plot(firstEma), plot(lastEma), color=color.new(isBullish ? bullColor : bearColor, 80))

Exercise 3: Create a Tiered Feature Script

Build an indicator that has:

  • Free tier: A simple moving average crossover with buy/sell arrows.
  • Premium tier (toggled via input.bool()): Adds a Bollinger Band overlay using ta.bb(close, 20, 2) and highlights when price touches the outer bands during a crossover signal.

Test both tiers on a chart to verify the premium features only appear when enabled.

Pro Tips and Common Pitfalls​

Publishing Tips
  • Test on multiple symbols and timeframes before publishing. An indicator that works on AAPL daily may break on a 1-minute crypto chart due to volume differences or missing data.
  • Use format.mintick in str.tostring() when displaying prices to match the symbol's decimal precision automatically.
  • Start with open source to build credibility. Your first 5-10 scripts should be free and high-quality. Followers gained from free scripts are your future paying customers.
  • Pin a comment on your published script with FAQs, known issues, and links to your other scripts.
  • Keep descriptions updated when you release new versions. Outdated descriptions erode user trust.
Common Pitfalls
  • Do not use runtime.error() -- this function does not exist in Pine Script v5. If you need to alert users about invalid configurations, use label.new() to display a warning message on the chart.
  • Do not assume math.random() exists -- Pine Script has no random number generator. All calculations are deterministic.
  • Do not try to obfuscate code within Pine Script itself. Source protection is handled by TradingView's publish settings (Open Source, Protected, or Invite-Only). Attempting code obfuscation violates house rules.
  • Do not republish frequently to bump your script in search results. TradingView moderators flag this behavior and may restrict your publishing privileges.
  • Do not forget the disclaimer. Always include a statement that your script is not financial advice. This protects both you and your users.

Next Steps​

Congratulations! You have completed the Pine Script course. You now have the skills to build indicators and strategies from scratch, optimize their performance, test them rigorously, and share them with the world. Here is what to do next:

  • Publish your first script -- even a simple one. The best way to learn the publishing process is to go through it.
  • Join the Pine Script community on TradingView. Read other authors' open-source code. Answer questions. Collaborate.
  • Keep iterating -- your first script will not be your best. Each version you release teaches you something new about both Pine Script and what traders actually need.
  • Stay current -- TradingView regularly updates Pine Script with new functions, features, and best practices. Follow TradingView's blog and release notes.

The journey from "Hello World" to a polished, published indicator is one of the most rewarding paths in algorithmic trading. You have all the tools. Now go build something great. 🎓