TradingView Pine Script to Automated Bot for Prop Firm Accounts

Every “no-code trading bot” post shows you a screenshot of a dashboard and tells you to trust it. If you’re the kind of trader who reads r/algotrading before buying a tool, that’s not proof of anything. This blog tells you about tradingview automation for prop firm accounts.

So this one shows you the actual alertcondition() line, the actual JSON payload, and the actual TradingView dialog fields instead.

This is the code-level version. You already trust your Pine Script strategy. This shows you how to wire a real alert into it, then route that alert to one or several funded prop firm accounts. No Python, no VPS, no broker SDK.

Key Takeaways

• alertcondition() and strategy.entry() both support alert messages; you only need one line of Pine to make a strategy alert-capable.
• The webhook JSON payload is three fields: action, symbol, and contract count, filled in with TradingView placeholders like {{strategy.order.action}}.
• Pine Script v6 removed the when parameter from order functions, a common reason converted alerts silently stop firing.
• One TradingView alert can fan out to every prop firm account in a trade group, each with its own contract multiplier.
• TradingView caps active alerts by plan (Essential: 20, Plus: 100, Premium: 400), which limits how far you can scale before upgrading.

Before You Start

You need three things:

• A Pine Script strategy or indicator with a condition you’d actually trade.
• A TradingView plan that allows active alerts.
• A funded or evaluation account at a prop firm that permits algorithmic execution. Apex, Topstep, Tradeify, and most Tradovate- or Rithmic-based firms all qualify.

You don’t need a coded strategy.entry() backtest engine. A plain indicator with a buy/sell condition works the same way.

The distinction that trips people up first: an alert-capable script is not the same as a strategy that’s already alerting. TradingView doesn’t auto-generate alerts from a plotted signal. You have to explicitly tell Pine which conditions should trigger a message, which is the whole first step below.

For the fundamentals of TradingView’s alert system before you touch any code, see the TradingView alert setup guide.

How Do You Write a Pine Script Alert That Actually Fires?

The fastest path is alertcondition() on an indicator, or wrapping your entries in strategy.entry() calls with alert_message set, if you’re already running a strategy() script. Either one gives TradingView something to listen for; neither requires a broker connection inside Pine itself.

Here’s a minimal alertcondition() block on top of an existing signal:

//@version=6
indicator("Alert-Ready Signal", overlay=true)

fastMA = ta.sma(close, 9)
slowMA = ta.sma(close, 21)
buySignal = ta.crossover(fastMA, slowMA)
sellSignal = ta.crossunder(fastMA, slowMA)

alertcondition(buySignal, title="Buy Signal",
     message='{"action":"buy","symbol":"{{ticker}}","contracts":1}')
alertcondition(sellSignal, title="Sell Signal",
     message='{"action":"sell","symbol":"{{ticker}}","contracts":1}')

The part most tutorials skip: the message string inside alertcondition() isn’t optional decoration. It’s the exact payload TradingView sends to your webhook. If you leave it as the default “alert triggered on {{ticker}}” text, your automation tool receives a sentence, not structured data, and has nothing to parse.

If your script is a full strategy() instead of an indicator(), attach the alert to the order call directly:

//@version=6
strategy("Alert-Ready Strategy", overlay=true, margin_percent=0)

fastMA = ta.sma(close, 9)
slowMA = ta.sma(close, 21)

if ta.crossover(fastMA, slowMA)
    strategy.entry("Long", strategy.long,
         alert_message='{"action":"buy","symbol":"{{ticker}}","contracts":1}')

if ta.crossunder(fastMA, slowMA)
    strategy.entry("Short", strategy.short,
         alert_message='{"action":"sell","symbol":"{{ticker}}","contracts":1}')

Notice both examples wrap the condition in an if block rather than a when= parameter. Pine Script v6 removed when from every strategy.*() order function, so old-style conditional entries copied from a v5 tutorial will compile fine and silently stop gating your orders. If you’re migrating an existing v5 script, our Pine Script v6 breaking changes guide covers every place that bites.

Turn the Alert Into a Live Order

Open the alert dialog from your script’s right-click menu or the alarm-clock icon, then work through four fields:

1. Condition — your indicator or strategy.
2. Trigger frequency — set this to Once Per Bar Close, not the default “Once Per Bar.”
3. Notifications → Webhook URL — paste the endpoint your automation account generated.
4. Message — leave whatever you set in alertcondition() or alert_message alone. Don’t overwrite it with TradingView’s default text.

Save it. TradingView starts firing your JSON payload the moment the condition is true.

The webhook itself comes from your automation account, not from Pine. In PickMyTrade, that’s a unique URL generated per connected broker, paired with a JSON template that mirrors whatever fields your alertcondition() or alert_message already sends. If your Pine code above outputs action, symbol, and contracts, your webhook template should expect those exact three keys.

Set Once Per Bar Close rather than the default “Once Per Bar.” A condition that flickers intrabar and fires on every tick can burn through TradingView’s per-alert trigger cap in seconds. The platform pauses the alert instead of queuing the overflow. That’s a silent failure that looks identical to a broken webhook.

What breaks first-time setups: the single most common reason a test signal never arrives isn’t the webhook URL. It’s the trigger frequency, left on “Once Per Bar” for an intrabar crossover condition. That fires multiple times before the bar closes and floods the endpoint with duplicate payloads.

Fire a manual test from the alert dialog before you trust it with money. PickMyTrade’s alert log shows the exact payload that reached the endpoint, which tells you in seconds whether the problem is the Pine code, the webhook config, or the broker connection. For the full JSON reference and every placeholder TradingView supports, see the webhook automation guide.

How Do You Route That Alert to Multiple Prop Firm Accounts?

Wire the same webhook to a trade group instead of a single account. One Pine Script alert then fires proportionally sized orders across every funded account in that group at once. This is where the “no-code bot” stops being a single-account toy and becomes something you can actually scale income from.

Prop firms cap how many accounts you can run in parallel, and the caps are more generous than most traders assume:

Internal copy trading, routing your own strategy across accounts you own, is permitted at all four. What’s banned everywhere is external copying: selling or subscribing to someone else’s signal feed. The distinction matters because a webhook fan-out to your own accounts falls squarely inside the allowed category.

What actually differs per account: three prop firm accounts on the same signal almost never want the same contract count. A 1% risk trade on a $100K account is roughly double the size of the same risk on a $50K account. Set that ratio once per account as a multiplier, and every future alert respects it automatically instead of you doing mental math mid-session.

To configure it:

1. Create a trade group.
2. Add each connected account as a follower.
3. Assign a contract multiplier per account, relative to your largest one. A common split: 0.5x for a $25K account, 1x for $50K, 2x for $100K.

One alert, several proportionally sized orders, zero extra Pine code. For the deeper walkthrough on sizing and drawdown-aware pausing across accounts, see our multi-account copy trading guide. For a real 30-day run across five firms at once, read one alert, five prop firms.

Test the Bot Before You Risk a Funded Account

Run every new alert through a paper or simulation connection first. Confirm the payload and fill match what your Pine code intended, then point the same webhook at a live account. Skipping this step is how a misconfigured contract multiplier turns into a drawdown violation on real money.

Before you scale past one or two accounts, check your TradingView plan against how many active alerts that actually requires. Each strategy variant, and often each account-specific alert, counts against the same cap.

Regular alerts are also rate-limited to roughly 15 triggers every 3 minutes, on top of the plan ceiling. A strategy trading a fast-moving futures contract with alert.freq_all instead of alert.freq_once_per_bar_close can hit that ceiling during a volatile open. The alert pauses instead of queuing. If your bot goes quiet during exactly the sessions that matter most, check trigger frequency before you check the webhook.

What Breaks in Production and How Do You Fix It?

Most failures after go-live trace back to one of three things. A when= condition that didn’t survive v6 conversion. An alert cap you didn’t know you’d hit. Or a duplicate signal firing twice because the trigger frequency was left too loose.

None of them throw a compile error. Why would a script that compiles clean ever get flagged as broken?

How support tickets on this actually break down: roughly a third trace back to alert configuration, like a wrong trigger frequency or an expired alert on a lower-tier plan. Another third is Pine-side logic: a missing if wrapper, or a message string left as default text. A fifth comes from hitting the plan’s alert cap outright. The remainder are broker-side rejections, mostly margin or symbol mismatches.

The fix for each is mechanical once you know where to look. Audit every order function for a stray when=. Count your active alerts against your plan’s cap. Switch flickering conditions to alert.freq_once_per_bar_close. For the longer list of Pine errors that show up outside a v6 migration specifically, see the 10 common Pine Script mistakes guide.

Ready to wire your Pine Script strategy to a funded account? PickMyTrade turns the webhook and JSON above into live orders across 27+ supported prop firms for $50/month flat, with sub-200ms execution and no per-account fees. Start with one alert and a 1-contract test order before you fan out to a full trade group.

Frequently Asked Questions

Conclusion

The gap between “I have a Pine Script strategy” and “my funded account trades it automatically” is smaller than most guides make it look, and it’s not a coding problem. It’s three fields in a JSON message, one alert dialog configured correctly, and a webhook that knows where to send the payload.

• Add alertcondition() or alert_message with a real JSON body, not the default text
• Set trigger frequency to Once Per Bar Close to avoid duplicate fires and alert-cap burnout
• Audit for the v6 when= removal before trusting a converted script
• Route through a trade group, not a single webhook, once you’re ready to scale to more than one account

Test with one contract on one account first. Once that fill matches what your Pine code intended, scaling to a full trade group is a config change, not a rewrite.

About the Author

PickMyTrade Team builds and maintains the webhook infrastructure that routes TradingView Pine Script alerts to brokers like Tradovate and Rithmic across 27+ supported prop firms, including Apex, Topstep, and Tradeify. The team writes from direct experience running this exact alert-to-broker pipeline for 10,000+ active traders. Learn more about PickMyTrade or get in touch.

Disclaimer:
This content is for informational purposes only and does not constitute financial, investment, or trading advice. Trading and investing in financial markets involve risk, and it is possible to lose some or all of your capital. Always perform your own research and consult with a licensed financial advisor before making any trading decisions. The mention of any proprietary trading firms, brokers, does not constitute an endorsement or partnership. Ensure you understand all terms, conditions, and compliance requirements of the firms and platforms you use.

Also Checkout: How to Connect Claude AI to TradingView Using MCP