How to Automate a TradingView Strategy Without Writing Pine Script

There is a particular kind of frustration that comes from having an indicator that works and no way to let it trade.

You have watched it for weeks. You know how it behaves in chop, you know when to stand aside, you trust the signal. What you cannot do is be at the screen for every one of them — and the moment you try to hand that job to TradingView, you find out that the wall isn't where you expected it. It isn't the alert, and it isn't the connection to your broker. It's that the indicator you actually trade is closed source. You cannot open it, cannot read it, and cannot convert it into anything that places an order.

Every tutorial you find assumes the opposite. This article explains why that gap exists, what actually closes it, and the one piece of the architecture most tutorials leave out — the piece that matters most once real money is involved.

Why an indicator cannot place an order

On TradingView, an indicator and a strategy are two different kinds of object, and the difference is the whole problem.

An indicator draws. It answers exactly one question: now. Long, or short. That's the entirety of what it knows and the entirety of what it can tell you. The alert it fires is a notification — it carries no order, no size, no exit.

An order needs considerably more. How many contracts, on which symbol, at what order type, with the stop where, the target where, into which account, and what to do if a position is already open. Seven answers the indicator does not have, and cannot have, because none of that is its job.

That gap has a name on TradingView: the strategy layer. A strategy places orders, holds a target and a stop, respects a session window, and can be run through the Strategy Tester. Closing the gap means turning your indicator into one — which normally means rewriting it as a strategy() script in Pine.

The advice that assumes you own the source code

Search for how to do this and you will find the same instruction everywhere: take your indicator, add strategy.entry and strategy.exit, and you're done.

That instruction works. It works if you can see the code.

The indicators people actually pay for — ours included — are published as closed, invite-only scripts. You can run them on your chart. You cannot read a line of them. So the standard advice quietly assumes an open-source indicator, and for a large share of the tools traders are genuinely running, it describes a door that isn't there.

Which leaves three options, and only one of them survives contact with a protected script.

Route	What it costs	Where it breaks
Rewrite the indicator in Pine Script yourself	Weeks of learning, then debugging	Impossible on a closed script. You would be reverse-engineering behaviour you cannot read.
Hire a Pine Script developer	Several hundred dollars and a wait	Same source-code problem — and every parameter change is a new invoice.
Use a strategy that reads the indicator's plotted output	One configuration session	Requires the indicator to expose its signal as a selectable plot

The route that doesn't need the code

Pine Script has a feature that makes the third option possible, and it is easy to miss: a strategy can take another script's plotted output as an input.

The mechanism is worth stating precisely, because it is often described loosely. The strategy does not read the indicator's code, and it does not interpret the arrows on your chart visually. It takes the series the indicator publishes as output — the same values it is already drawing — and uses that as its trigger. The indicator stays untouched, unopened, and exactly as its author wrote it.

That is what TIS Automator is: a Pine Script v5 strategy built around reading another script's plot. It takes the signal and builds a complete order around it — entry, target, stop, session, size — then fires a standard TradingView strategy alert that any execution gateway can consume.

Indicator → TIS Automator → Strategy alert → Gateway → Broker

Everything up to the alert happens inside TradingView. Everything after it belongs to your gateway and your broker. The strategy forms the order; it never touches your account. That boundary matters, and there is a section on it below.

One condition governs whether any of this applies to your indicator: it has to expose its signal as a plot you can select. Most do. Some don't, and there is no way to tell from the outside — not from the description, not from the screenshots, not from asking. This is why a free trial exists rather than a compatibility list. You load your own indicator, open the dropdown, and either your signal is in there or it isn't. Two minutes, on your own chart, with your own tools. Don't take anyone's word for it, including ours.

What the setup actually involves

Once the signal source is connected, the work is configuration rather than construction. In order:

1. Your indicator goes on the chart as it always has. Nothing is required of it except that it plots something.

2. The strategy goes on the same chart and you point it at your indicator's output from a dropdown. TradingView populates that list with every plot available. Choosing the right one is the entire integration.

3. You choose how the signal is read. Some indicators plot a single series that flips sign with direction — positive long, negative short, zero flat. Oscillators like MACD and CCI swing through zero and express the signal as a crossing between two series instead. Both shapes are handled, and which one applies is visible on the chart immediately: the entries should land exactly where you already expect them.

4. You set your target and stop in ticks, along with position size and the session window you want to trade.

5. You create one alert on the strategy, with the condition on order fills and your gateway's payload in the message body.

Two of those deserve more than a line, because they are where automated setups quietly go wrong months later.

Ticks, not points

Twenty points on NQ and twenty points on MNQ are the same distance in price and a very different amount of money. If your exits are written in points, every symbol change means recalculating your risk from scratch, and the day you forget is the day it costs you.

In ticks, the same numbers behave identically on the full contract and on the micro. You size the risk once and move between instruments without touching the settings. It sounds like a detail. It is the difference between a configuration you can trust and one you have to re-verify every time you switch.

Sessions that survive the clock change

The session window is TradingView's native session input, anchored to exchange time rather than to a fixed hour offset. Daylight saving does not silently shift your trading window twice a year.

Anyone who has built a time filter with a hardcoded offset knows why this is worth mentioning. The filter works perfectly for four months and then, one Monday in spring, starts trading an hour off — and nothing in the chart tells you.

The alert, and where it usually fails

The last step is one alert, created on the strategy, with the condition set to order fills and your gateway's payload template pasted into the message body using TradingView's strategy placeholders. Each gateway publishes its own format — PickMyTrade, CrossTrade, TradersPost and PineConnector all document theirs.

That message is where most attempts at automation fail, and they fail silently: the alert fires, nothing arrives, and no error appears anywhere. We covered why in a separate article, because the reasons are specific and worth reading before you go live. 

Where your stop and target actually live

This is the part most tutorials skip, and misunderstanding it is how people get hurt. It is not specific to any one tool — it is how TradingView automation works, whatever sits in the middle.

Your target and your stop do not exist at your broker.

When the strategy sets a take profit and a stop loss, those levels live inside TradingView's strategy engine. TradingView watches its own price feed. When the feed touches one of those levels, the engine fills the order — and that fill event is what fires the alert your broker receives.

So what travels down the chain is never "place a stop at X." It is "exit now, at market." Your broker is a mirror: it replicates fills, it does not hold protective orders.

Three consequences you should understand before funding an account:

1. Match your exit order type to your gateway's payload. If the payload sends a limit price on the exit, that order can sit unfilled while your position stays open. Verify it in simulation before it matters.
2. With nothing resting at the broker, a TradingView outage leaves the position unattended. There is no second system watching the level. This is the single most important thing to understand about the architecture.
3. The gateway is where you fix that. Some gateways accept take profit and stop loss values in the order payload itself and pass them through to the broker as attached orders — giving you protection that survives an outage on TradingView's side. PickMyTrade documents this for both of its broker paths, Tradovate and Rithmic, which is more than most gateways publish. Check your own gateway's payload specification before assuming either way.

What automation does not do

Worth being explicit, because this category attracts inflated claims.

It does not generate signals — your indicator does that, and this builds orders from what your indicator already produces. It does not improve a losing strategy; automating rules with no edge produces losses faster and more consistently than trading them by hand. And it does not remove risk. What it removes is hesitation, missed entries, and unplaced stops. Those are execution errors, not market risk, and they are the ones worth eliminating first.

The structural benefit is easier to undersell than to overstate: an indicator cannot be run through TradingView's Strategy Tester at all. Once your signal drives a strategy, the platform's own testing and reporting apply to it — equity curve, trade list, drawdown, on something that was never written to be testable. To be precise about what is doing the work there, the Strategy Tester is TradingView's feature, not ours. What changes is that your indicator becomes eligible for it.

Before any live capital is involved, run the setup in simulation and confirm at least ten orders arrive intact: right contract, right size, stop and target attached.

Simulated trading is based on hypothetical results and does not reflect actual trading. Emotional and psychological factors of real-money risk are not replicated. Use simulation to verify your setup, not as an indicator of live performance.

Frequently asked questions

Can I automate a TradingView strategy without knowing how to code?

Yes. A strategy script takes your indicator's plotted output as its trigger, and the order parameters are set in a settings panel. No Pine Script is written.

Can I automate an indicator I bought if it's closed source?

Yes, provided it exposes its signal as a selectable plot. You never need to open or modify it.

Do I need a paid TradingView plan?

Yes. Webhook alerts require a paid tier, and the number of active alerts you can hold varies by plan. Check TradingView's current pricing page.

Do I need a VPS or a computer left running?

No. The strategy runs on TradingView's servers and the alert fires from there.

Which broker does this work with?

That is determined by your execution gateway, not by the strategy. Whatever your gateway supports is what you can trade.

Where do my stop and target actually sit?

Inside TradingView, not at your broker. The exit reaches the broker as a market order when the level is hit. Some gateways can also pass the levels through to the broker as attached orders — check your gateway's payload specification

Will automating my strategy make it profitable?

No. It executes your rules consistently. Whether those rules have an edge is a separate question, and the only honest answer is that it depends on the rules.

The route described above is TIS Automator, a Pine Script v5 strategy. The only test that settles anything is whether your own indicator's signal appears in the dropdown — two minutes on your own chart, which is exactly why there is a free trial. See how it works →

This material is for educational purposes only and is not a recommendation to buy or sell any instrument. Futures trading involves substantial risk of loss and is not suitable for all investors. TIS Automator generates alerts inside TradingView; it does not execute trades and does not connect to any broker. Backtested and past performance does not guarantee future results. You are responsible for compliance with your broker's and your funding provider's rules