Pine Script via Claude
Automate your trading without writing code

[1. Who I am and what I trade]
I trade BTC perpetuals on the 1-hour chart with USD 10K on
Binance USDT-M Futures.

[2. Entry conditions]
Go long when the close breaks the prior 20-bar high
(excluding the current bar) AND RSI(14) > 50.

[3. Exit conditions]
Close when price breaks the prior 10-bar low. Or when price
retraces ATR(14) × 2 from the post-entry high.

[4. Risk rules]
Stop = entry-bar low minus ATR(14) × 0.5.
Max risk per trade = 1% of account.
Max one position at a time, no pyramiding.

[5. Output spec]
Output a complete Pine Script v6 strategy(). Don't add alertcondition()
(alertcondition() is for indicator() scripts only — a strategy() script's
alerts fire on order fills).
Don't write alert(), JSON, or a webhook secret in the Pine code.
I'll paste TVSBot's "TV template" single-line JSON into the TradingView
alert dialog, in this format:
{"secret":"<your webhook secret>","strategy":"<your TVSBot strategy name>","action":"{{strategy.order.alert_message}}","symbol":"BTCUSDT","exchange":"binance","market_type":"futures","qty_type":"margin_usdt","qty":50,"leverage":3}
I'll fill in the secret myself on TradingView.
How to fill action: with no exit logic at all, use {{strategy.order.action}}.
As soon as the strategy has an exit (strategy.close / strategy.exit / stop-loss / take-profit),
every strategy.entry / strategy.close / strategy.exit must set alert_message
(entries "buy" / "sell", exits "close" — action word only;
to flip, call strategy.close(..., alert_message="close") first and then strategy.entry in the new direction (its own "buy"/"sell"):
two fills = two alerts, so TVSBot fully closes before opening the new side — don't rely on an opposite-direction strategy.entry alone,
since TVSBot sizes every order by its own qty and a fixed-margin "sell" does not cleanly flip a long), and the action in the
alert-dialog JSON becomes {{strategy.order.alert_message}}
({{strategy.order.action}} only sends buy/sell, never close, so an exit would be treated as an ordinary trade and not close cleanly).

Pine Script v6 strategy().
Entry: close > ta.highest(high, 20)[1] (the prior bar's value, not current).
Exit: close < ta.lowest(low, 10)[1].
Stop loss: entry-bar low minus 0.5 * ta.atr(14).
Sizing: 100% equity (default_qty_value=100, default_qty_type=strategy.percent_of_equity).
No alertcondition(), and no alert() or JSON inside the Pine (alerts fire on order fills; I paste the JSON in the alert dialog).
Every strategy.entry / strategy.close / strategy.exit must set alert_message — the action word only, never a secret:
long entry alert_message="buy", short entry alert_message="sell", every exit that explicitly calls strategy.close / strategy.exit (stop, take-profit, flatten) alert_message="close".
To flip, first call strategy.close(..., alert_message="close"), then strategy.entry in the new direction (alert_message="buy"/"sell"): two fills = two alerts, so TVSBot fully closes first and then opens the new side.
Don't rely on an opposite-direction strategy.entry alone: TVSBot sizes every order by its own qty, so a fixed-margin "sell" does not cleanly flip a long (depending on position mode it may only reduce it partially, or reverse it with the wrong size).
Because {{strategy.order.action}} only ever sends buy/sell, never close,
the single-line JSON I paste into the alert dialog uses {{strategy.order.alert_message}} as its action:
{"secret":"<your webhook secret>","strategy":"<your TVSBot strategy name>","action":"{{strategy.order.alert_message}}","symbol":"BTCUSDT","exchange":"binance","market_type":"futures","qty_type":"margin_usdt","qty":50,"leverage":3}
pyramiding=0, process_orders_on_close=true.

Pine v6 strategy().
Long entry: ta.crossover(ta.ema(close, 20), ta.ema(close, 60)).
Short entry: ta.crossunder(ta.ema(close, 20), ta.ema(close, 60)).
Stop: 0.3% below ema60 for longs, mirror for shorts.
Take profit: 1:2 risk/reward (target = entry + risk*2).
pyramiding=0. On a reverse signal, close first and then reverse (see below).
No alertcondition(), and no alert() or JSON inside the Pine (alerts fire on order fills; I paste the JSON in the alert dialog).
Every strategy.entry / strategy.close / strategy.exit must set alert_message — the action word only, never a secret:
long entry alert_message="buy", short entry alert_message="sell", every exit that explicitly calls strategy.close / strategy.exit (stop, take-profit, flatten) alert_message="close".
To flip, first call strategy.close(..., alert_message="close"), then strategy.entry in the new direction (alert_message="buy"/"sell"): two fills = two alerts, so TVSBot fully closes first and then opens the new side.
Don't rely on an opposite-direction strategy.entry alone: TVSBot sizes every order by its own qty, so a fixed-margin "sell" does not cleanly flip a long (depending on position mode it may only reduce it partially, or reverse it with the wrong size).
Because {{strategy.order.action}} only ever sends buy/sell, never close,
the single-line JSON I paste into the alert dialog uses {{strategy.order.alert_message}} as its action:
{"secret":"<your webhook secret>","strategy":"<your TVSBot strategy name>","action":"{{strategy.order.alert_message}}","symbol":"BTCUSDT","exchange":"binance","market_type":"futures","qty_type":"margin_usdt","qty":50,"leverage":3}

Pine v6 strategy().
RSI period 14.
rsiLong = ta.crossover(ta.rsi(close, 14), 30) and close > ta.ema(close, 200)
rsiShort = ta.crossunder(ta.rsi(close, 14), 70) and close < ta.ema(close, 200)
Long entry: rsiLong
Short entry: rsiShort
Long exit: ta.rsi(close, 14) >= 50 OR close < ta.ema(close, 200)
Short exit: ta.rsi(close, 14) <= 50 OR close > ta.ema(close, 200)
Stop: fixed -1.5% (ranges don't have ATR-friendly volatility patterns).
No alertcondition(), and no alert() or JSON inside the Pine (alerts fire on order fills; I paste the JSON in the alert dialog).
Every strategy.entry / strategy.close / strategy.exit must set alert_message — the action word only, never a secret:
long entry alert_message="buy", short entry alert_message="sell", every exit that explicitly calls strategy.close / strategy.exit (stop, take-profit, flatten) alert_message="close".
To flip, first call strategy.close(..., alert_message="close"), then strategy.entry in the new direction (alert_message="buy"/"sell"): two fills = two alerts, so TVSBot fully closes first and then opens the new side.
Don't rely on an opposite-direction strategy.entry alone: TVSBot sizes every order by its own qty, so a fixed-margin "sell" does not cleanly flip a long (depending on position mode it may only reduce it partially, or reverse it with the wrong size).
Because {{strategy.order.action}} only ever sends buy/sell, never close,
the single-line JSON I paste into the alert dialog uses {{strategy.order.alert_message}} as its action:
{"secret":"<your webhook secret>","strategy":"<your TVSBot strategy name>","action":"{{strategy.order.alert_message}}","symbol":"BTCUSDT","exchange":"binance","market_type":"futures","qty_type":"margin_usdt","qty":50,"leverage":3}

Pine v6 strategy().
BB(20, 2.0): destructure with [bbMiddle, bbUpper, bbLower] = ta.bb(close, 20, 2.0)
MACD(12, 26, 9).
Long: close > bbUpper AND MACD line > MACD signal AND MACD line > 0
Short: close < bbLower AND MACD line < MACD signal AND MACD line < 0
(Note: ta.bb() returns a [middle, upper, lower] tuple — middle comes first,
 and it cannot be indexed, so it must be destructured.)
Stop: ta.atr(14) * 1.5
Exit: ATR trailing stop using ta.atr(14) * 3
No alertcondition(), and no alert() or JSON inside the Pine (alerts fire on order fills; I paste the JSON in the alert dialog).
Every strategy.entry / strategy.close / strategy.exit must set alert_message — the action word only, never a secret:
long entry alert_message="buy", short entry alert_message="sell", every exit that explicitly calls strategy.close / strategy.exit (stop, take-profit, flatten) alert_message="close".
To flip, first call strategy.close(..., alert_message="close"), then strategy.entry in the new direction (alert_message="buy"/"sell"): two fills = two alerts, so TVSBot fully closes first and then opens the new side.
Don't rely on an opposite-direction strategy.entry alone: TVSBot sizes every order by its own qty, so a fixed-margin "sell" does not cleanly flip a long (depending on position mode it may only reduce it partially, or reverse it with the wrong size).
Because {{strategy.order.action}} only ever sends buy/sell, never close,
the single-line JSON I paste into the alert dialog uses {{strategy.order.alert_message}} as its action:
{"secret":"<your webhook secret>","strategy":"<your TVSBot strategy name>","action":"{{strategy.order.alert_message}}","symbol":"BTCUSDT","exchange":"binance","market_type":"futures","qty_type":"margin_usdt","qty":50,"leverage":3}

Add a session filter to my existing EMA Cross strategy:
- Use hour(time, 'UTC') to get the current UTC hour.
- Define inSession = hour >= 0 and hour < 8.
- Add "and inSession" to the entry conditions only.
- Open positions follow normal stop/take logic regardless of session.
- Don't change the strategy() declaration or the existing order logic.

Net Profit:     +$4,820 (48.2% on $10K)
Total Trades:   31
Win Rate:       38.7% (12W / 19L)
Avg Win:        +$543
Avg Loss:       -$132
R:R:            4.1
Max Drawdown:   -$1,210 (-12.1%)
Sharpe:         1.82

// Bad: uses unclosed current bar's high
entrySignal = high > ta.highest(high, 20)

// Good: locked to prior closed bar
entrySignal = high[1] > ta.highest(high[1], 20)

I have the Turtle System 2 specification:
- Entry: break above prior 55-day high (long) / below prior 55-day low (short)
- Exit: opposite 20-day break
- Stop: 2N rule (N = 20-day ATR), 2% account risk per unit
- Pyramiding: add 1 unit per 0.5N favorable move, max 4 units
- Position limits: 4 per market, 6 per correlated group, 12 directional

Write this as a Pine v6 strategy() for BTC/USDT 1D.
pyramiding=4. N = ta.atr(20). Per-unit risk = 2% account via
strategy.percent_of_equity. Keep inline comments referencing
the original Turtle rules so I can tune them later.