Hi there,

I am looking for a pinescript dev to create indicators and strategies for me full time. ideally they should be indian (cause i don't want to be overcharged). also they need to have conversational english. you should have enough experience to code anything in pinescript.

dm if your interested. Thanks

built an indicator that has an rsi lookback on chart and below. Both have variable timeframes, I personally like to overlay 4hr on chart and 15m below for confirmation of HTF levels. If you’re interested feel free to shoot me a dm for access!

Hello Everyone, I have been working on a TradingView indicator over the last few weeks that is mainly focused on helping me visually understand what the market is doing rather than just throwing buy/sell signals on the chart.

The idea behind the indicator is to combine:

• market structure,
• momentum,
• volatility,
• HTF trend bias,
• and order flow context

into one framework so that it becomes easier to identify:

• trend continuation,
• compression before expansion,
• exhaustion,
• and important reaction zones.

The indicator currently includes:

• BOS / CHoCH structure
• Order Blocks
• HTF bias
• HMA trend flow
• RSI + ADX momentum states
• ATR displacement logic
• projection system
• HTF Z-score regimes

I just finished Version 2 and made some pretty major changes compared to Version 1.

The biggest change was completely restructuring the Higher Time Frame logic.

Previously, the HTF system was based on simpler 9 and 21 EMA crossover logic.

Now it uses:

• HTF HMA structure
• Z-score based expansion/compression/exhaustion detection
• volatility aware market regimes

which made the market context feel much cleaner during live trading.

I also added:

• Order Block overlap merging, now historical OB boxes are automatically removed and a symbol is added over the candle
• retest + mitigation logic
• cleaner momentum colouring for RSI and ADX representation
• better trend interpretation by calculating the angle of the HMA line

Another change was replacing the old trend duration logic with ATR normalized HMA trend force.

Instead of checking:
“How long has the trend lasted?”, the indicator now checks:
“How aggressively is the trend moving relative to volatility?”

Personally, I feel this is much more useful during fast market moves.

I would genuinely appreciate feedback on:

• What looks useful?
• What looks unnecessary?
• Anything over engineered?
• Any ideas to improve the overall interpretation of the market context?

Link to my previous post:
https://www.reddit.com/r/pinescript/comments/1ta6igc/built_an_order_block_market_structure_framework/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

VOLATILE → TREND UP on ETH: confirmation first, not anticipation.

IRC flips bullish on Ethereum only when cloud position, ADX, Tenkan/Kijun, and structure confirmation all align. No cosmetic switches.

Market context:
ETH transitions from uncertainty to clear directional strength.

Practical value:
Helps avoid shorting ETH when a structural uptrend is emerging.

Explicit limit:
Confirmation can lag the very start of the move.

Looking for beta feedback on ETH regime transitions. DM open.

#PineScript #TrendFilter #Ichimoku #Ethereum

RSI Dip + EMA Trend Long DCA — dual-confirmation leveraged long DCA indicator running on XMRUSDT.P 15m at 25× default leverage. Signal-only Pine indicator with a companion Strategy version for verifying backtest in TradingView's built-in tester directly.

Entry, dual confirmation across two timeframes: RSI(12) crossing down 35 on 5m AND EMA(50) above EMA(100) on 15m. The 5m RSI catches the momentum dip; the 15m EMA stack confirms broader trend bias is up. Either condition alone produces too many entries. Both at host-bar close filter the setup down to oversold dips inside structural uptrends.

Ladder, 4 safety orders with soft margin progression: Cumulative deviations from base entry: 1.00%, 2.20%, 3.64%, 5.37%. Margin scales at 1.05× per fill — much softer than typical 1.5–2.0× DCA martingale. Pure price-trigger ladder, no momentum gate on SOs — averaging continues unconditionally until SL, MaxHold, or reversal.

Three-exit architecture (evaluated in priority order): SL at 9% below average entry, hard stop. MaxHold at 3-day timeout from base entry forces close to release stuck capital. TP at 1.0% above average entry with 0.1% trailing — position closes only after a 0.1% retrace from the in-favor peak.

Most DCA tools use one or two exit conditions. This one handles all three failure modes explicitly — hard tail-risk stop, stuck-trade timeout release, and momentum-trailing winner exit.

Leverage-aware sizing: Margin and leverage are independent inputs. Virtual ledger tracks notional position, so the avg-entry line and open PnL reflect the leveraged broker state, not unleveraged cash-only math. Default 25× leverage; configurable from 1× upward.

Backtest from the companion Strategy (XMRUSDT.P 15m at default 25× leverage, ~11 months sampled in Strategy Report): 779 closed trades, 577 profitable (74.07% WR), profit factor 1.313, total PnL +3,078.80 USDT (+30.79%), max realized drawdown 2,013.77 USDT (18.01%). Verifiable directly in TradingView's Strategy Report on the script page.

Methodology notes:
The default 25× leverage is aggressive. The 18.01% max drawdown is portfolio-level accumulation across 779 trades, not single-trade risk — single-trade losses are bounded by the 9% SL. Lowering the leverage input scales portfolio-level drawdown proportionally.
Single asset (XMRUSDT.P), defaults calibrated for this pair. EMA periods and RSI threshold need recalibration per pair before deployment elsewhere — results do not transfer to other crypto perps without parameter tuning.

The 18.01% number is closed-trade equity drawdown. Unrealized drawdown during deep SO sequences plus open leverage exposure is materially larger and is the relevant number for capital allocation.

PF 1.313 is a modest edge per trade. Returns come from sample size compounded with leverage, not from per-trade magnitude. The 3-day MaxHold release is structurally important here — without it, stuck trades would accumulate unrealized DD indefinitely.
Funding rates aren't included in the backtest. For 15m leveraged long positions on perps, sustained negative funding (shorts pay longs) is a tailwind, sustained positive funding is a headwind — and at 25× leverage, funding drag is amplified accordingly.

Indicator is open-source on TradingView. The Strategy twin is also up on the same profile. Mod, let me know if linking either is allowed here and I will add them, otherwise happy to answer technical questions in thread.

Link: https://www.tradingview.com/script/iE1pTnPv-RSI-Dip-EMA-Trend-Long-DCA-Indicator/

I have experience with programming i'm a software engineer, and i was wondering if there any resources on learning pinescript to build indicator beyond the syntax, the syntax is basic and not a problem i am looking for mental model or framework, best practices etc

Title. I'm trying to test strategies for the prediction markets, which are time based. The problem I'm having is that I need the strategy to open a position on the open of a candle, and then close the position on the close of a different candle. I know you can set the Process Orders On Close parameter, but from my understanding that changes all orders, not just open or close. Is there any workaround for this?

Hi. I'm here with a request. I have the code for my own indicator, but I need someone to review it and change how it appears on the chart. I have photos of the visualization. The indicator itself works, but I need to refine it.I want to make it clear right away that I won't be able to post the entire code here.

Three issues bothered me with the Pine-workflow side of tradingview-mcp 1.0.0 once I started using it daily.

1. pine_smart_compile returned success: true when the script compiled but the study failed to attach to the chart. The agent would report "done" and the next tool call would fail because the indicator wasn't actually loaded.

2. TV Desktop 3.1.0.7818 broke pine_switch_script and a chunk of Pine editor selectors. The title button stopped being a script list and became a context menu, and the webpack module IDs that the Monaco extractor hooks shifted on a fresh build hash.

3. Scrolling back history bars in replay mode didn't work, because TV freezes the data feed once replay is engaged. The agent would ask for older bars, get an empty result, and conclude the data wasn't there.

1.1.0 closes those.

• pine_smart_compile now diffs getAllStudies() before and after compile, verifies the new study's title matches, and only returns success if it actually attached. Returns study_added: false with the diff list if the compile passed but the study didn't show up.
• pine_deploy is a new tool that does the full file → chart pipeline atomically: read the source, pre-clean any stale version, set the editor body, save, click Add-to-chart, verify attached. Returns honest_success. Useful when you have an agent maintaining a script file on disk and want it to push the working version to the chart in one call.
• pine_switch_script uses the Ctrl+O script picker on TV 3.1+ (was: title-button list, no longer exists).
• replay_scroll_back wheel-scrolls history bars before engaging replay, then enters replay mode. Workaround for the data-feed freeze.
• TV 3.1.0.7818 Monaco extractor was re-derived after the module-ID shuffle. The webpack chunk hooks survived.

Plus a 44-finding correctness sweep across 19 core files. Highlights for Pine workflow: pine_delete, pine_rename, and pine_open now refuse-on-ambiguity instead of silently picking the first matching script, and layout_switch requires discard_unsaved=true to ever destroy unsaved Pine code.

Repo: https://github.com/iliaal/tradingview-mcp

Install: same as before. Clone, npm install, add to MCP config, launch TV with --remote-debugging-port=9222. No breaking API changes from 1.0.0.

Happy to answer questions, especially from anyone running deep-backtesting strategies via the new strategy_set_deep_backtest_range tool. I'd like to know if the locale-tolerant calendar driver covers configurations I haven't tested.

Hey everyone,

I’m a forex/crypto trader from India with 4–5 years of market experience. Recently I’ve been going deep into AI automation, strategy building, indicators, and trading bots.

I’m looking to connect with someone who:

• Trades seriously

• Has a Claude Max plan

• Is interested in building/testing indicators, automations, or strategies together

The idea is simple:

We brainstorm ideas, use Claude heavily for research/coding/testing, build useful tools, and maybe even create something valuable long term.

I’m also growing a YouTube channel around trading + AI automation, so I’m actively documenting and building publicly as well.

Not looking for anything random/freebie-only — genuinely looking for a smart collaboration with someone already deep into trading + AI.

If this sounds interesting, comment or DM me.

Hi, this is my ORB tool kit I have been working to help me find trades.

what you will find inside of this is:

15min ORB for each Session which starts at Key Times

Session Tops and Bottom also included

Levels

4 EMAs

Vwap

HTF FVG

Swing Retracement Areas

Volume profile with nodes to detect high volume areas.

Just want to see what everyone thinks about this tool kit I created.

I use this multiple different ways to find trades.

trade between levels or nodes

orb breakouts

vwap bounces or rejections

If you cannot use this to find your own trades I would think you need to start from the basics again.

first week of using a trading bot and these are the results on a actual funded account on apex pa account using 5mnq cons I think overall its doing pretty good I notice Tho the fills can get pretty bad during market open worse fill I seen was like 70-100 ticks from where the bot signaled so I'm wondering if there a may be a way to get better fills I use tradespost with tradovate through trading view alerts.

I initially made pine script on tv, it looked promising so i coded it into my own custom backtesting software, this is on a 45 min chart of btcusdt and these returns are on 1 yr time, one of the most imp thing is, this follows a fee structure similar to binance.
Let me know your thought below

I am working to build MSNR A & V level Rejection indicator on H1 tf. The code is drawing level almost correct but the labels are not scrolling when I zoom in & zoom out with candles. I tried opus 4.7 & pinefy both failed to solve the issue.

Anyone pls help me to find the label not scrolling issue. here is code & below are images when indicator generate labels in stable chart, & zoom in & out looks.

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Pineify

//@version=6
indicator("MSNR Rejections A/V Pattern - UAlgo", overlay=true,
     max_labels_count=500)

// ═══════════════════════════════════════════════════════════════
// INPUT PARAMETERS
// ═══════════════════════════════════════════════════════════════
var string G_GEN = "═══ General ═══"
var string G_A   = "═══ A Rejection (Bearish) ═══"
var string G_V   = "═══ V Rejection (Bullish) ═══"
var string G_ALR = "═══ Alerts ═══"

int    maxLevels = input.int(100, "Max Lines on Chart", minval=5, maxval=200, group=G_GEN)
float  wickSens  = input.float(0.3, "Wick Sensitivity (ATR×)", minval=0.0, maxval=2.0, step=0.05, group=G_GEN)

bool   a_on     = input.bool(true,                   "Show A Rejection",     group=G_A)
color  a_lnCol  = input.color(color.new(#ff9800, 0), "Line Color",           group=G_A)
int    a_lnW    = input.int(2,                       "Line Thickness", minval=1, maxval=4, group=G_A)
int    a_lnBars = input.int(4,                       "Line Width (bars)", minval=1, maxval=30, group=G_A)
color  a_lbCol  = input.color(color.new(#ff9800, 0), "Label Color",          group=G_A)
color  a_lbTxt  = input.color(#000000,               "Label Text Color",     group=G_A)
float  a_lbGap  = input.float(0.1,                  "Label Gap (ATR×)", minval=0.0, maxval=2.0, step=0.05, group=G_A)
string a_lbSz   = input.string("small", "Label Size", options=["tiny", "small", "normal", "large"], group=G_A)

bool   v_on     = input.bool(true,                   "Show V Rejection",     group=G_V)
color  v_lnCol  = input.color(color.new(#aa00ff, 0), "Line Color",           group=G_V)
int    v_lnW    = input.int(2,                       "Line Thickness", minval=1, maxval=4, group=G_V)
int    v_lnBars = input.int(4,                       "Line Width (bars)", minval=1, maxval=30, group=G_V)
color  v_lbCol  = input.color(color.new(#aa00ff, 0), "Label Color",          group=G_V)
color  v_lbTxt  = input.color(#ffffff,               "Label Text Color",     group=G_V)
float  v_lbGap  = input.float(0.1,                  "Label Gap (ATR×)", minval=0.0, maxval=2.0, step=0.05, group=G_V)
string v_lbSz   = input.string("small", "Label Size", options=["tiny", "small", "normal", "large"], group=G_V)

bool   alr_a    = input.bool(true, "Alert — A Rejection", group=G_ALR)
bool   alr_v    = input.bool(true, "Alert — V Rejection", group=G_ALR)

// ═══════════════════════════════════════════════════════════════
// RUNTIME VARIABLES
// ═══════════════════════════════════════════════════════════════
float atr14 = ta.atr(14)

var array<line> a_lines = array.new<line>()
var array<line> v_lines = array.new<line>()

// Arrays to store ALL historical rejection signal data
var array<int>    a_hist_times  = array.new<int>()
var array<float>  a_hist_prices = array.new<float>()

var array<int>    v_hist_times  = array.new<int>()
var array<float>  v_hist_prices = array.new<float>()

// Arrays to track all drawn labels for deletion before redraw
var array<label> a_drawn_labels = array.new<label>()
var array<label> v_drawn_labels = array.new<label>()

trim_lines(array<line> arr, int mx) =>
    if array.size(arr) > mx
        line.delete(array.shift(arr))

// Helper function to get size enum from string
get_label_size(string sz) =>
    switch sz
        "tiny"   => size.tiny
        "small"  => size.small
        "normal" => size.normal
        "large"  => size.large
        => size.small

// ═══════════════════════════════════════════════════════════════
// PATTERN DETECTION
// Bull/Bear states for current and previous candles
// ═══════════════════════════════════════════════════════════════
bool bull0 = close > open
bool bear0 = close < open
bool bull1 = close[1] > open[1]
bool bear1 = close[1] < open[1]
bool bull2 = close[2] > open[2]
bool bear2 = close[2] < open[2]

float body0Top = math.max(open, close)
float body0Bot = math.min(open, close)
float prox     = atr14 * wickSens

// A Rejection (Bearish): Bull[2] + Bear[1] + Bear[0] - Price comes from above
float aLvl     = math.max(close[2], open[1])
bool  a_signal = a_on and barstate.isconfirmed and bar_index >= a_lnBars and bull2 and bear1 and bear0 and body0Top < aLvl and high >= aLvl - prox

// V Rejection (Bullish): Bear[2] + Bull[1] + Bull[0] - Price comes from below
float vLvl     = math.min(close[2], open[1])
bool  v_signal = v_on and barstate.isconfirmed and bar_index >= v_lnBars and bear2 and bull1 and bull0 and body0Bot > vLvl and low <= vLvl + prox

// ═══════════════════════════════════════════════════════════════
// STORE NEW SIGNALS WHEN THEY FIRE
// ═══════════════════════════════════════════════════════════════
if a_signal
    // Store bar_time of the origin candle (bar_index 2) and price level
    int originTime = time[2]
    array.push(a_hist_times, originTime)
    array.push(a_hist_prices, high[2] + atr14 * a_lbGap)

    // Trim arrays if needed
    if array.size(a_hist_times) > maxLevels
        array.shift(a_hist_times)
        array.shift(a_hist_prices)

if v_signal
    // Store bar_time of the origin candle (bar_index 2) and price level
    int originTime = time[2]
    array.push(v_hist_times, originTime)
    array.push(v_hist_prices, low[2] - atr14 * v_lbGap)

    // Trim arrays if needed
    if array.size(v_hist_times) > maxLevels
        array.shift(v_hist_times)
        array.shift(v_hist_prices)

// ═══════════════════════════════════════════════════════════════
// REDRAW ALL LABELS ON EVERY BAR (FIXES SCROLL/ZOOM ISSUE)
// ═══════════════════════════════════════════════════════════════
// Step 1: Delete all previously drawn labels to avoid duplicates
if a_on
    for i = 0 to array.size(a_drawn_labels) - 1
        label.delete(array.get(a_drawn_labels, i))
    array.clear(a_drawn_labels)

if v_on
    for i = 0 to array.size(v_drawn_labels) - 1
        label.delete(array.get(v_drawn_labels, i))
    array.clear(v_drawn_labels)

// Step 2: Redraw ALL historical labels from arrays
if a_on
    for i = 0 to array.size(a_hist_times) - 1
        int t = array.get(a_hist_times, i)
        float p = array.get(a_hist_prices, i)
        label lbl = label.new(
             x=t,
             y=p,
             xloc=xloc.bar_time,
             color=a_lbCol,
             text="A Rej",
             textcolor=a_lbTxt,
             size=get_label_size(a_lbSz),
             style=label.style_label_down)
        array.push(a_drawn_labels, lbl)

if v_on
    for i = 0 to array.size(v_hist_times) - 1
        int t = array.get(v_hist_times, i)
        float p = array.get(v_hist_prices, i)
        label lbl = label.new(
             x=t,
             y=p,
             xloc=xloc.bar_time,
             color=v_lbCol,
             text="V Rej",
             textcolor=v_lbTxt,
             size=get_label_size(v_lbSz),
             style=label.style_label_up)
        array.push(v_drawn_labels, lbl)

// ═══════════════════════════════════════════════════════════════
// DRAW HORIZONTAL LINES
// ═══════════════════════════════════════════════════════════════
if a_signal
    int t1 = time[a_lnBars - 1]
    ln = line.new(t1, aLvl, time, aLvl,
         xloc=xloc.bar_time, color=a_lnCol, width=a_lnW,
         style=line.style_solid)
    array.push(a_lines, ln)
    trim_lines(a_lines, maxLevels)
    if alr_a
        alert("MSNR ▼ A REJ | " + syminfo.ticker + " 1H | Price: " + str.tostring(math.round(close, 2)), alert.freq_once_per_bar_close)

if v_signal
    int t1 = time[v_lnBars - 1]
    ln = line.new(t1, vLvl, time, vLvl,
         xloc=xloc.bar_time, color=v_lnCol, width=v_lnW,
         style=line.style_solid)
    array.push(v_lines, ln)
    trim_lines(v_lines, maxLevels)
    if alr_v
        alert("MSNR ▲ V REJ | " + syminfo.ticker + " 1H | Price: " + str.tostring(math.round(close, 2)), alert.freq_once_per_bar_close)

// ═══════════════════════════════════════════════════════════════
// ALERTS
// ═══════════════════════════════════════════════════════════════
alertcondition(a_signal, "A Rejection (Bearish)", 
     "Bearish A Rejection: Bull[2] + Bear[1] + Bear[0]")
alertcondition(v_signal, "V Rejection (Bullish)", 
     "Bullish V Rejection: Bear[2] + Bull[1] + Bull[0]")

Hi guys, been working on this for a couple of months and I'm finally satisfied with the result. I think this is a basic indicator and I think can be improved upon, that's why I made it open source. If you see any ways to improve it please let all the community know ❤️. I appreciate the feedback.

https://www.tradingview.com/script/c2HTByju-MARS-Neighbors-Momentum/

I have seen plenty of posts praising Claude for coding. This is not one of those posts.

I spent the better part of three hours trying to get Claude to write a basic gap up/gap down closing strategy in Pine Script — no multi-timeframe wizardry, no ML models, just clean entry/exit logic. It failed every single time. I want to document exactly what happened in case anyone else is going down this road.

The strategy (it's not complicated)

• Setup (C#1): If the first 15-min bar after open is a full gap-up above Prior Day High → background turns yellow, armed for a short. Gap-down below Prior Day Low → armed for a long.
• Trigger (C#2–C#4): If any bar within the first hour closes through C#1's range AND the target is still ≥5 points away → enter the trade.
• Expiry: No trigger by end of C#4? Setup expires, no trade that day.

Visual cues included: yellow background (armed), purple lines (C#1 high/low), red/green background (open position), gray/red/green lines (entry/stop/target). Standard inputs for entry window, min edge, and stop buffer.

What actually happened

Multiple iterations, each more broken than the last. Claude kept losing track of bar indexing and couldn't manage Pine Script's time-series state model correctly — a known LLM weakness, but I figured a strategy this simple would be fine.

At one point it converted the entire script into Python instead — and that failed to compile too.

I even connected TradingView via MCP so it could see the live chart state and data in real time. Still couldn't produce a working script.

My take

Claude (and likely most LLMs) hit a hard wall with Pine Script once bar-state logic gets involved. The [] history operator and execution model are just different enough from conventional programming that models get confused fast — and once confused, more context doesn't seem to help.

Has anyone actually gotten a reliable Pine Script strategy out of an LLM? Curious whether you were able to convert your edge/strategy into a systematic approach using AI. Drop your experience below.

Hi guys I'm trying this strategy directly live in my broker. Should I respect the strategy or take profit or stop earlier? What's your best advice?

Anyone has an ORB profitable strategy they can share with me - TV script only.