TradingView Automation Guide

This lesson covers automation on TradingView. This is more complex than, for example, TradeSanta. But it has lots of advanced tools that thousands of traders appreciate.

If you are a complete beginner and never wrote a line of code, I would recommend you to leave this tool for later. But if you are ready, you are welcome!

Let's get started!

---

Part 1. Quick-Start

Before we wire-up webhooks or let a bot place even a single trade, we need a home base where charts live and strategies run. For me — and for most retail quants — TradingView is that home base. Think of it as Bloomberg-lite in your browser: all the major markets, an ever-growing library of public strategies, plus built-in alerts that can fire off to the outside world (webhooks, e-mail, SMS, Telegram…).

Why TradingView?

• Zero-install – everything runs in a tab; no Windows-only desktop hurdles.

• Strategy Tester – one click turns any Pine Script into a back-test with detailed stats.

• Massive script library – thousands of public indicators/bots to copy, fork or adapt.

• Webhooks & automation – TradingView will happily POST a JSON payload the moment your strategy goes long or flat, which is the cornerstone of no-code bot building.

So, let's create an account.

If you already trade on TradingView, scroll down to the Part 2.

1. Open TradingView’s sign-up page.

2. Sign-up via email or any other method (Google, Facebook, etc)

3. TradingView asks for permission Click Grant Access. This simply allows the brokerage portal (or any partner app) to open your TradingView workspace after login.

4. TradingView launches automatically Within a second or two you should land on a default chart—usually the S&P 500 or BTCUSD.

If this is your first time on TradingView, I recommend you to spend at least 2-3 hours to see how it works and what it is used for. Algorithmic Trading is just one of many features.

1. Purchase subscription ("Essential" or higher). TradingView itself has a free version, but automation is only available with subscription.

Continue reading whenever you are ready.

---

Part 2: Hunting for a free, profitable TradingView strategy

To find a free strategy (and maybe edit it later), you should scout the public strategy library.

1. Open Super-Charts Log in to TradingView, hover Products ▸ Super Charts, click once. A blank chart opens.

2. Load the Bitcoin daily chart

   • Search-box (top-left) → type BTCUSD (or any other currency pair that you want to trade) → choose Index (or a major exchange).

   • Check the timeframe ribbon under the symbol; if it shows anything but 1D click the ▼ arrow and select 1 Day.

   • Wheel-scroll to zoom in/out; you want a few years of data visible.

3. Open the Indicators panel Tap / or click Indicators. In the search field type strategy – TradingView now filters only scripts that output trades (they end with Strategy).

1. Ignore private or pay-walled code The very first list (under My scripts) is yours; the next headers (Technicals, Community Scripts) are public and free.

2. Attach a candidate Double-click SuperTrend Strategy (or RSI, MACD, Momentum – try anything). TradingView instantly runs a back-test and pops the Strategy-Tester panel.

3. Read the scoreboard

   • Net profit – we want green, ideally triple-digit %.

   • Max draw-down – stay < 20 % in crypto; that means the equity curve never sank deeper than that.

   • Win-rate & expectancy – not vital if profit is large, but > 40 % wins feels comfortable.

4. Declutter the chart Click the ⚙️ on the strategy’s name → Style tab → untick Signal labels and Position size so only blue buy ▲ and red sell ▼ arrows remain.

1. Reality-check Scroll back. Does every entry make sense? A few losers are fine; whole “waterfalls” of red trades are a red flag. When you like what you see, keep the script – we’ll automate it next.

Why we need more than TradingView alone?

A TradingView alert can fire a JSON payload the second your strategy flips from flat to long (or vice-versa). But an alert can’t log in to Bybit and press Buy for you – that’s where a thin “glue-layer” comes in.

Below is the no-code chain we’ll assemble in Parts 3–5:

vbnetCopyEdit┌──────────────┐      webhook (JSON)      ┌──────────────┐
│  TradingView │──────────────────────────▶│     Make     │
│  strategy &  │                          │ (Integromat) │
│   alert      │◀─optional error/OK───────│    Router    │
└──────────────┘                          └────┬─┬─┬─────┘
                                               │ │ │  filters:
                                               │ │ │  – ticker = BTCUSD
                                               │ │ │  – action = buy / sell
                     HTTP POST “enterLong”─────┘ │ └─HTTP POST “enterShort”
                                                 │
                                                 ▼
                                         ┌──────────────┐
                                         │ WunderTrading│
                                         │  Signal Bot  │
                                         └────┬──┬──┬───┘
                                              │API key
                                              ▼
                                         ┌──────────────┐
                                         │   Exchange   │
                                         │ (e.g. Bybit) │
                                         └──────────────┘

What each block does

• TradingView – runs the SuperTrend Strategy on the 1-day BTCUSD chart; when a blue ▲ appears it fires {"ticker":"BTCUSD","action":"buy"} (or "sell").

• Make.com – catches that webhook, checks ticker is indeed BTCUSD, then sends the correct enterLong or enterShort template to WunderTrading.

• WunderTrading Signal-Bot – already knows your Bybit sub-account and its API key. When it receives enterLong it market-buys BTC with 100 % of the USDT balance; on enterShort it sells everything back.

• Exchange (Bybit, Kraken, etc.) – executes the orders in real time. You never expose your master account; each bot lives in its own sub-account.

That’s the big picture. In the next part we’ll build the puzzle from left to right: create the webhook in Make, send a test alert from TradingView, and let Make learn the payload structure. From there wiring the buy/sell branches becomes drag-and-drop easy.

---

Part 3 – Wiring TradingView to Make.com

(catch a test signal and teach Make what to do with it)

3.1 Setup Make (formerly Integromat)

1. Create a free account Go to make.com, click Get started, register with Google/e-mail, confirm the mail.

2. Start a fresh scenario

   • Dashboard ▸ Scenarios ▸ Create a new scenario (purple ➕).

   • Ignore the “Choose apps” wizard – we’ll add modules manually.

1. Add the Webhook catcher

   • Click the big grey + in the middle.

   • Search “Webhooks” ▸ choose Custom Webhook ▸ Listen for a new request.

   • Click Add, give it a memorable name (e.g. TV_BTC_signals), leave IP restriction empty.

   • Press Save.

   • Make now shows “Waiting for data…” and displays a long URL – copy it (clipboard icon).

     This is the address TradingView will call every time the strategy fires.

Pause! Keep the Make tab open – it must receive one real alert so it can learn the payload structure.

3.2 Set up the TradingView test alert

(one-minute chart, only for teaching Make)

1. Jump to a fast timeframe On the BTCUSD chart change the interval to 1 m – this forces the strategy to spit a buy/sell within minutes instead of days.

2. Open the alert dialog Click the ⏰ Alert button (or hit Alt +A).

3. Fill the basics

• Condition: select your strategy, not “Crossing”.

• Name: SuperTrend | BTC | 1-min TEST.

1. Payload (Message box) Delete the default text, paste this JSON:

jsonCopyEdit{
   "ticker":"{{ticker}}",
   "action":"{{strategy.order.action}}"
}

No spaces after the field names, Make likes it lean.

1. Point it to Make

• Tick Webhook URL in the Notifications block.

• Paste the long address you copied from Make.

1. Create the alert and watch it appear in the right-hand Alerts panel.

☕ Wait until you see one BUY and one SELL fire in the Alerts log (blue/green flash). Because we’re on the 1-minute chart it normally happens within 2-3 minutes.

1. Delete the test alert once both directions have triggered – we don’t want the 1-minute bot to trade real money later.

3.3 Continue the Make setup

1. Confirm Make caught the sample Switch back to the Make tab. The Webhook bubble should now display “Successfully determined” and show two keys: ticker and action. Click OK.

2. Branch the flow – buy or sell

   • Hover the Webhook module ▸ small wrench icon ▸ Add router. You now have one input and two empty outputs.

3. Add a filter for the correct symbol

• Click the tiny funnel on the line between Webhook and Router.

• Name: Only_BTCUSD.

• Condition: ticker  –  equals  –  BTCUSD ▸ OK.

1. Prepare placeholders for later – no coding! After listening to the sample Make now auto-suggests ticker and action tokens you can drag into any future module.

1. Save the scenario (but keep it OFF) Click Save top right, name it SuperTrend_BTC_NoCode. We’ll finish the HTTP calls to WunderTrading in the next part; for now your Webhook + Router skeleton is ready and understands the test alert structure.

---

Checkpoint

You should see…	Meaning
Webhook bubble shows Successfully determined	Make knows the JSON keys.
A Router with two arms	Ready to send BUY and SELL down separate paths.
Filter Only_BTCUSD before the router	Accidental ETH/LTC alerts are ignored.

If that matches your screen – congrats, the TradingView → Make half of the pipeline is alive.

---

Part 4 – Plugging WunderTrading into Your Exchange

4.1 Create / connect a Bybit spot sub-account

Using a clean sub-account keeps the bot’s money separate from your manual trades and lets us trade 100 % of the balance without fear.

1. Log in to Bybit (or any other available crypto exchange). – If you don’t have an account yet, open one. – Complete KYC if the platform asks; you’ll need API access later.

1. Open the sub-account manager • Avatar ▸ Sub-account ▸ Create sub-account ▸ Standard ▸ Unified trading. • Username must be globally unique – I prefix my initials, then the strategy name, e.g.

objectivecCopyEditMK_SuperTrend_BTC

• Click Confirm. The empty sub-account appears in the list.

1. (Optional) Seed it with test funds • Transfer ▸ Across sub-accounts. • From: any spot account that holds USDT (or USDC) ▸ To: MK_SuperTrend_BTC. • Amount: 100 USDT is plenty for a first run.

Why spot, not futures? This guide is about low-stress, non-leveraged swing trading. Futures add funding fees, liquidation risk, and dramatically higher engineering risk. Master spot first – add leverage later if you really need it.

4.2 Generate an API Key + Secret for WunderTrading

1. In the sub-account list press API Management (or Manage ▸ API).

2. Create New Key ▸ System-generated.

3. Third-party application ▸ WunderTrading (important: API keys tied to a listed partner do not expire).

4. Permissions

   • Scope: Read + Write

   • Products: Unified trading (Spot) only – leave Derivatives unchecked.

5. Submit ▸ pass 2FA / e-mail confirmation.

1. Copy the API Key and Secret immediately – the secret is shown once and never again. – Keep the browser tab open until you’ve pasted them into WunderTrading.

4.3 Attach Bybit to WunderTrading

1. Sign in at wundertrading.com (new users start on a 7-day Pro trial – enough for live testing).

2. Sidebar ▸ Exchange Accounts ▸ Connect exchange ▸ choose Bybit (Spot).

3. Paste the API Key and Secret you just created.

4. Account nickname – paste the exact sub-account name (MK_SuperTrend_BTC).

5. Connect. – WT does a quick permission check; if you seeded the sub-account you’ll see its USDT balance in the list.

4.4 Build a TradingView Signal-Bot in WunderTrading

The Signal-Bot provides two unique webhook payloads – enterLong and enterShort. Those are what we’ll paste into Make so the router’s BUY and SELL branches can hit the correct endpoint.

Sidebar ▸ Signal Bot ▸ Create bot ▸ TradingView bot.

1. General tab

   • Name – again, mirror the sub-account: MK_SuperTrend_BTC.

   • Exchange – Bybit.

   • Account – select the MK_SuperTrend_BTC sub-account.

   • Pair – BTC/USDT.

   • Time-frame – 1D (matches our chart).

2. Order settings

   • Order type – Market (fast & simple).

   • Position size – 100 % (converts the entire available USDT to BTC on a buy, and vice-versa on a sell).

   • Max positions – 1.

   • Keep positions open – off (unchecked).

3. Create bot and Save.

Immediately hit Edit again – a new panel called TradingView alerts template appears:

Action	Copy this JSON (exactly)
Enter long	{ "side":"buy", "amount_type":"percent","amount":"100" }
Enter short	{ "side":"sell", "amount_type":"percent","amount":"100" }

Under each template you’ll also see the Webhook URL – one URL, two bodies. Copy the URL now; we’ll need it twice in Make.

Tip: If you plan several bots (ETH, SOL, etc.) keep a Notion page with their names • sub-accounts • webhook URLs • enterLong / enterShort bodies – saves hunting later.

4.5 Back to Make – finish the HTTP calls

1. BUY branch (left output of the router)

   • Open the empty HTTP – Make a request module.

   • Method: POST

   • URL: paste the Signal-Bot’s webhook URL.

   • Body type: Raw.

   • Content-type: application/json.

   • Request content: paste the Enter long JSON from step 4.

2. SELL branch (right output)

   • Same setup, but paste the Enter short JSON.

3. Save ▸ give the scenario a clear name (SuperTrend_BTC_Make2WT).

4. Turn the scenario ON (top-right toggle). – Green check-mark = active listener.

4.6 Quick health-check

Component	What to verify
WunderTrading	Bot status shows Waiting for signal. Exchange balance visible.
Make	Scenario switch = ON. Webhook queue = 0/0.
TradingView	The 1-minute test alert was deleted. Only the **SuperTrend

If all three nodes are green, your first no-code TradingView bot is fully wired:

luaCopyEditTradingView  ➜  Make (router / filters)  ➜  WunderTrading bot  ➜  Bybit sub-account

Next market open/close generated by the SuperTrend strategy will:

1. Hit Make’s webhook,

2. Flow through the BUY or SELL branch,

3. Call WunderTrading,

4. Market-buy or market-sell 100 % of the sub-account balance.

How are you doing? We are almost there!

---

Part 5 – “Production Mode”

Simple guard-rails that keep your bot running (and warn you when it doesn’t).

5.1 Renew the TradingView alert every 60 days

Free & Pro alerts expire. If the webhook stops firing, Make never receives a signal and the whole chain silently dies.

Routine

Day-0 action	Calendar reminder
When you create/modify the alert, open the Expiration picker and push it out 2 months.	Immediately drop a recurring reminder into Google / Outlook: Renew BTC SuperTrend 1D alert – TradingView – repeat every 2 months, 1-day early.

You’ll need ~60 seconds: open alert ▶ Edit ▶ click Expiration calendar ▶ push date ▶ Save.

5.2 Heartbeat e-mail from Make

Make can ping you once per day to prove the scenario is still ON and webhook quotas aren’t exhausted.

1. Open your SuperTrend_BTC_Make2WT scenario.

2. Click the empty canvas, choose Tools ▸ Scheduler.

3. Drag it above the Webhook, set:

   • Run once every day at 08:00 UTC (or whatever suits).

4. After the Scheduler add Email ▸ Send an e-mail.

   • From: [e-mail] (pre-configured).

   • To: your main inbox.

   • Subject: Make heartbeat – SuperTrend_BTC.

   • Body:

     luaCopyEdit{{now}} UTC  
     Scenario status: OK  

5. Save ▶ Turn scenario back ON.

Now your inbox proves every morning that Make is alive. Didn’t arrive? — Investigate before New York opens.

5.3 Lightweight P&L log in Google Sheets

You don’t have to build a full-blown dashboard; one append-only row per execution is enough.

1. Create a Google Sheet

Column	Purpose
Timestamp	webhook reception time
Side	BUY / SELL
Qty BTC	Amount executed
Price	Fill price (avg)
Balance USDT	Balance after trade

2. Add a Sheets “Append row” inside Make

1. In Make hit + after the router’s BUY branch.

2. Choose Google Sheets ▸ Add a row.

3. Connect your Google account (OAuth popup).

4. Pick the spreadsheet and the Log sheet.

5. Map fields:

   • Timestamp → {{now}}

   • Side → static “BUY” (do same for SELL branch with “SELL”).

   • Qty BTC + Price + Balance → drag from WT webhook JSON (amount, price, balanceUSDT).

Every fill instantly lands in Sheets → you can chart P&L or reconcile taxes later.

5.4 Three closing tips

Habit	Why it matters
Version labels – any time you tweak filters or JSON bodies, clone the scenario and append _v2, _v3…	Roll-back in 1 click if the new logic misbehaves.
Withdraw regular profits to another wallet.	Reduces capital at risk and makes performance “real”.
Stay curious, but add bots slowly.	One clean, monitored bot beats five half-configured ones.

You’re live 🎉

That was hard, I know. It may take several attempts to make it. If needed, you may watch other guides on YouTube or ask TradingView support. I tried to make this guide as simple as possible, but I understand that it still takes time to figure out.