A TradingView alert that only pings your phone is half a system. The moment worth acting on — a non-repainting indicator confirming on bar close — still requires you to see the notification, open your broker, and place the trade by hand. Webhooks close that gap. They take the exact payload TradingView sends the instant an alert fires and deliver it directly to a broker, a bot, or an automation platform, so the action happens in the same second the signal confirms, not whenever you happen to check your phone.
Before you wire anything to a broker, read how an alert on an open bar can fire on a signal that disappears at the close in our guide to non-repainting indicators.
This guide walks through exactly how TradingView webhooks work, what you need before the option even appears (a paid plan and two-factor login), how to wire one up to any broker or no-code automation tool without writing a script, the JSON payload structure that makes alerts machine-readable, how to lock the endpoint down, and the safety checks that keep an automated alert pipeline from silently misfiring while you’re not watching it. It’s the click-by-click companion to the automation section of our complete TradingView guide, which covers plans, alerts, Pine Script and data feeds together.
⚡ Key Takeaways
- A TradingView webhook is just an HTTP POST request TradingView sends to a URL you provide the instant an alert condition fires — no coding is required to set one up on the TradingView side
- Three gates come before anything else: a paid plan (the free Basic plan has no webhooks), two-factor authentication switched on for your account, and a receiving URL on port 80 or 443 that answers within three seconds
- The alert message field controls the entire payload; a valid JSON message is sent as
application/json, anything else goes out as plain text — which is why one typo can turn a clean order into garbage - TradingView sends every webhook from four published IP addresses, so you can lock your receiving server to those and add a shared secret inside the payload as a second check
- Webhooks fire on the exact bar-close event your indicator confirms on — pairing them with a repainting indicator means the automation executes on a signal that may not have existed when the bar was live
- A production webhook pipeline needs three safety layers most first-time setups skip: a test-mode dry run, a position-size cap, and an alert-delivery monitor that flags silent failures
What a TradingView webhook actually is
Strip away the automation-platform marketing language and a webhook is simple: it’s an HTTP POST request. When a TradingView alert condition is met, TradingView sends the contents of that alert’s message field to a URL you specified when you created the alert. Whatever service is listening at that URL receives the message and can act on it immediately — place an order, log the signal, send it to a Telegram bot, or trigger a broader automation chain.
This is fundamentally different from TradingView’s built-in notification types (app push, email, SMS, pop-up), all of which are designed for a human to read and then manually act on. A webhook is designed for a machine to read and act on, which is what makes true automation possible — no human latency between signal confirmation and execution.
The setup on TradingView’s side needs no code — you tick a box and paste a URL into the alert. The code, if any is needed, lives on the receiving end, and for most retail setups even that receiving end can be a no-code tool rather than custom-built infrastructure. Plan and account requirements are in the next section, because they are the first thing that trips people up.
One thing TradingView says plainly in its own documentation, and it is worth hearing before you build anything: its alerts are not designed for automated trading by its own wording. Delivery is best-effort. That does not make a webhook pipeline a bad idea, but it does mean the safety layers further down this page are not optional extras.
What you need before you start
Check these before you spend an hour on payloads. Each one has stopped a setup that otherwise looked perfect.
| Requirement | What TradingView says | What it means for you |
|---|---|---|
| Paid plan | The free Basic plan has no webhook notifications | You need Essential, Plus, Premium or Ultimate |
| Two-factor authentication | Webhook alerts are “only allowed when 2-factor authentication is enabled” | Turn on 2FA in your account security settings first, or the Webhook URL box will not work |
| Ports | Only 80 and 443 are accepted | A URL like https://example.com:8443/hook is rejected before it leaves TradingView |
| Response time | A request is cancelled if the server takes longer than three seconds | Answer first, do the slow work afterwards |
| IP version | IPv6 is not supported | Your endpoint must be reachable over IPv4 |
| Sending addresses | Four fixed IPs | 52.89.214.238, 34.212.75.30, 54.218.53.128, 52.32.178.7 — allowlist these if your server sits behind a firewall |
| Delivery | Webhooks “may occasionally fail” to reach the URL | Watch the Webhook status column in the alert log, and monitor your receiver too |
These come from TradingView’s own help page on how to configure webhook alerts, which we read again on 7 November 2026 while rewriting this guide. Two things in that list catch people. The three-second window is about your server’s reply, not about the order being placed, so a bridge that talks to a slow broker before it answers will look like a failed delivery even though the trade went through. And the port rule means a self-hosted receiver has to sit behind a normal web port, usually through a reverse proxy.
Which plan, and what it costs
TradingView’s plans today are Basic (free), Essential, Plus, Premium and Ultimate. The older plan names Pro, Pro+ and Expert are gone. The pricing page lists “Webhook notifications” as a plan feature, and the independent guides we compared list webhooks on all four paid plans and not on Basic. TradingView’s pricing table is the final word, so look at that row before you buy.
What differs between the paid plans is how many alerts you get and how long they live:
| Plan | List price, billed monthly (USD) | Billed yearly, per month (USD) | Price alerts | Technical (indicator and strategy) alerts | Alert lifetime |
|---|---|---|---|---|---|
| Basic | Free | Free | 3 | None listed | 1 month |
| Essential | $14.95 | $12.95 | 20 | 20 | 2 months |
| Plus | $34.95 | $29.95 | 100 | 100 | 2 months |
| Premium | $69.95 | $59.95 | 400 | 400 | Open-ended option |
| Ultimate | $239.95 | $199.95 | 1,000 | 1,000 | Open-ended option |
Source: plan names, alert counts and alert lifetimes from TradingView’s pricing page and its alert expiration help page, read on 2026-11-07. The US dollar figures are list prices as listed by two independent price trackers last updated in September and October 2026. TradingView’s own page is localised and shows discounted yearly “special” prices, so your checkout may differ by currency, tax and promotion.
The row that matters most for automation is the last one. On Essential and Plus an alert simply stops after two months. TradingView’s help page puts it this way: “Alerts have an expiration period, after which they will automatically stop.” Nothing is sent to your broker to tell it the automation has ended. If you run a live pipeline on one of those plans, put the expiry date in your calendar the day you create the alert. Open-ended alerts are a Premium and Ultimate feature, and even those are switched off if an alert is more than a year old and has neither fired nor been edited in a year.
A quick way to plan the count: a strategy alert usually needs one alert per chart, because the same alert carries both entries and exits. A plain indicator usually needs two, one for the buy condition and one for the sell. Three strategies on two symbols each is six alerts, which fits inside Essential’s 20. Watching dozens of symbols is a different budget problem, and we worked it through in how many symbols your alert budget really lets you watch.
Why webhook automation matters for non-repainting indicators specifically
The entire value proposition of a non-repainting indicator — a signal that holds its position after the bar closes rather than recalculating in hindsight — depends on acting on that signal at the moment it confirms. A signal you plan to check “when I get a chance” defeats the purpose of paying for a non-repainting tool in the first place, because the whole edge of non-repainting confirmation is that the signal is real and stable the instant it prints, not just in a backtest.
Webhook automation is the mechanism that actually captures that edge in practice. Quantzee’s AI TrendPulse and SuperTrend Pro+ are both built to confirm on bar close specifically so they can feed a webhook pipeline reliably — an alert fired from a repainting tool would trigger the automation on a signal position that might not have existed if you’d checked the chart a bar later, which turns automation from an edge into a live liability. (If SuperTrend is the signal you are alerting on, the live candle can flip and flip back, so use “Once per bar close”; the SuperTrend settings guide explains why.) Before wiring any indicator to a webhook, confirm it holds its signal after bar close using TradingView’s Bar Replay tool, exactly as covered in our guide on why backtests don’t match live trading.
Step 1: Create the alert on TradingView
Start from the chart with your indicator or strategy applied.
- Click the Alert icon (clock icon) in the right-hand toolbar, or right-click the chart and select “Add Alert.”
- Under Condition, select the indicator and the specific plot or signal you want to trigger on (for example, a SuperTrend flip, an RSI cross, or a strategy’s buy/sell signal if you’re alerting off a Pine Script strategy). If your Pine Script calls
alert()itself, pick “Any alert() function call” and the script decides what is sent and when. - Set the Trigger — critically, choose “Only Once” or “Once Per Bar Close”, never “Once Per Bar.” Triggering on every intrabar tick means the alert can fire on a value that hasn’t confirmed yet, which for a non-repainting indicator specifically undermines the entire reason you’re using one. Bar-close-only triggering is the automation-side equivalent of confirming your indicator doesn’t repaint.
- Set the Expiration. Remember the table above: on Essential and Plus the longest you can pick is two months, and the alert dies silently at that date.
- Under Notifications, check “Webhook URL” and paste the endpoint you’ll set up in Step 2. If the box will not tick, it is almost always two-factor authentication or the plan — see the requirements table.
- In the Message field, enter the payload — covered in detail below. This is the single most important field in the entire setup, because it’s the only thing the receiving service actually sees. Delete TradingView’s default message text first; a leftover sentence in front of your JSON stops it being valid JSON.
Two behaviours are worth knowing now, because they explain a lot of “it worked yesterday” complaints:
- An alert only watches the chart it was created on. The symbol and timeframe are fixed when you click Create. If you move to another chart and expect the alert to follow, it will not.
- A strategy alert freezes the strategy’s inputs at creation. If you change a length, a multiplier or an order size afterwards, the running alert keeps using the old values. Delete it and create a new one after any change.
And one safety valve you may trip without knowing: TradingView stops an alert that triggers too often, at more than 15 triggers in 3 minutes. A signal that flips back and forth on a fast chart can hit that in a single busy minute. If a pipeline went quiet after a volatile spell, check the alert log for that notice before blaming the receiver.
Step 2: Choose where the webhook sends data
You have four realistic paths, depending on technical comfort and what you’re automating toward. Whichever you pick, remember that an alert has room for exactly one webhook URL. If you want the same signal to reach two places, one of them has to forward it to the other on its own server or relay.
Path A — A broker with native webhook/alert support
Some brokers and trading platforms accept TradingView webhooks directly and translate the payload into an order without any middle layer. This is the simplest path when available: TradingView → broker webhook endpoint → order placed. Check your specific broker’s API documentation for a “TradingView webhook” or “alert-to-order” feature before building anything more complex — several retail-facing brokers across crypto, forex, and equities now support this natively, and it eliminates an entire integration layer.
Path B — A no-code webhook-to-broker bridge
For brokers without native webhook support, a growing category of no-code bridge tools exists specifically to translate a TradingView JSON alert into a broker API call. These tools work the same general way: you connect your broker account once through the bridge’s dashboard (API key entry, OAuth, or similar — no code), then point your TradingView webhook URL at the bridge’s endpoint instead of the broker directly. The bridge parses the JSON payload and places the corresponding order.
This is the realistic default for most retail traders wanting webhook automation without hiring a developer — the entire setup is dashboard clicks and copy-pasting a URL and a JSON template, on both the TradingView side and the bridge side. Some bridges also set their own rules on top of TradingView’s, such as required field names, a cap on requests per minute per URL, or a minimum chart timeframe. Read those before you design the alert, because TradingView will happily send a message the bridge then refuses. If you’re coming from a bot platform and wondering whether your alerts can still drive one, our 3Commas alternative comparison covers how 3Commas takes TradingView webhooks and when a signals-only setup is the better fit.
Path C — General-purpose automation platforms (Zapier, Make, and similar)
If you’re not automating a direct trade execution but instead want the alert to trigger something else — log to a spreadsheet, post to a Slack or Telegram channel, send an SMS through a service TradingView doesn’t natively support, or kick off a multi-step workflow — general no-code automation platforms accept an incoming webhook as a trigger and can format the payload into hundreds of downstream actions. Relay services work the same way and add one useful trick: one stable input URL can fan out to several destinations, each with its own small transform, so a Discord channel and a log file can both get the same alert in the shape each one wants.
This path is also useful as a first test step even if your end goal is broker execution: point your alert at a webhook-testing tool first, confirm the payload arrives correctly, then swap the URL for your actual broker or bridge endpoint once you trust the pipeline.
Path D — A small receiver you host yourself
If you can run a few lines of Python or Node, a self-hosted receiver gives you full control: you decide what is checked, logged and forwarded. Two practical points decide whether it works at all. First, TradingView cannot reach localhost or a laptop behind your home router, so the endpoint has to be on a public address. A small VPS works, and so does a tunnelling tool for testing. Second, because of the port rule, the server has to answer on 80 or 443, normally with a reverse proxy in front of your app. We give a minimal example in the “Host your own receiver” section further down.
Step 3: Build the JSON payload TradingView sends
The message field in your TradingView alert is what the receiving service actually parses, so its format matters more than any other single setting. A plain-text message like “Buy signal on the index” is fine for a human reading a push notification — it’s useless for a machine trying to place an order, because there’s no structured field for symbol, side, quantity, or order type.
A JSON payload solves this. TradingView supports variables inside the alert message that get substituted with live values when the alert fires, letting you build a dynamic, structured payload instead of hardcoding values per alert. A typical webhook message for a long entry looks like this:
{
"symbol": "{{ticker}}",
"action": "buy",
"price": {{close}},
"time": "{{time}}",
"strategy": "AI TrendPulse",
"timeframe": "{{interval}}"
}
The double-curly-brace variables ({{ticker}}, {{close}}, {{time}}, {{interval}}) are TradingView placeholders that auto-populate with the actual values at the moment the alert fires — you don’t manually edit them per alert, they resolve dynamically. This is what makes one alert template reusable across every symbol and timeframe you apply it to, rather than needing a unique hand-written message for every instrument.
What TradingView does with your message
TradingView does not require any particular field. There is no mandatory schema; the receiving end defines it. What TradingView does decide, automatically, is the content type of the request:
- If your message is valid JSON, the request goes out as
application/json. - If it is anything else, it goes out as
text/plain.
You cannot set this header yourself, and TradingView will not warn you when your JSON is broken. It just sends the text. Many bridges reject plain text, and some quietly mis-read it. TradingView’s own example is the bare minimum, a Slack-style message such as {"text": "BTCUSD Greater Than 9000"}. Always check your receiver’s documentation for the exact keys it wants.
The placeholder reference
These are the ones we reach for most. The full list sits in TradingView’s alert variables help page.
| Placeholder | What you get |
|---|---|
{{ticker}} | The symbol, such as AAPL or BTCUSD |
{{exchange}} | The exchange. Delayed symbols end in _DL or _DLY |
{{open}}, {{high}}, {{low}}, {{close}} | Prices of the bar the alert fired on, with a decimal point |
{{volume}} | Volume of that bar |
{{time}} | The bar’s time in UTC, as 2019-08-27T09:56:00Z |
{{timenow}} | The moment the alert actually fired, same format, to the nearest second |
{{interval}} | The chart timeframe. Price-based alerts can show 1 because they run on one-minute data |
{{plot_0}} to {{plot_19}} | The indicator’s output series, counting from zero |
{{plot("Name")}} | A plot picked by its name |
{{syminfo.currency}}, {{syminfo.basecurrency}} | Quote currency and base currency of the symbol |
A few details that bite in practice. {{time}} is the bar’s own timestamp, while {{timenow}} is the moment the alert fired; if you want to measure delivery delay, use {{timenow}}. {{plot_0}} only reads the first indicator in the alert, so a multi-indicator alert will not fill the second tool’s values. And a placeholder that can come back blank or as text should be wrapped in quotes in your JSON, otherwise an empty value leaves you with "price": , and the whole message stops being valid JSON.
For a strategy-based alert (as opposed to an indicator-based one), TradingView also exposes strategy placeholders. They only work on strategy alerts:
| Placeholder | What you get |
|---|---|
{{strategy.order.action}} | buy or sell for the order that just executed |
{{strategy.order.contracts}} | Size of that order |
{{strategy.order.price}} | Price it executed at |
{{strategy.order.id}} and {{strategy.order.comment}} | The order’s id and comment |
{{strategy.order.alert_message}} | The text you set in the strategy’s alert_message argument |
{{strategy.position_size}} | The current position size |
{{strategy.market_position}} | long, short or flat |
{{strategy.prev_market_position}} | The position before this order |
Use a strategy placeholder on a plain indicator alert and it arrives empty — a field your receiver may then read as zero or as a missing value. That is the most common cause of a webhook that “works” and does nothing.
A strategy payload that mirrors exactly what your backtested logic decided looks like this:
{
"key": "paste-your-own-long-random-string",
"symbol": "{{ticker}}",
"action": "{{strategy.order.action}}",
"qty": "{{strategy.order.contracts}}",
"position": "{{strategy.market_position}}",
"position_size": "{{strategy.position_size}}",
"sent_at": "{{timenow}}"
}
Sending the resulting position as well as the order is a cheap safeguard against duplicates. If the same “buy” arrives twice and the payload says the position is already long at the target size, a careful receiver can ignore the second one instead of doubling up. Some bridges build this in; if yours does not, you can do it in the receiver.
Whatever bridge or broker receives this payload will document its own expected field names (some want "side" instead of "action", some want "qty" instead of implying position size elsewhere) — match your JSON keys to what the receiving service’s documentation specifies, since the receiving end is what actually enforces the schema, not TradingView.
Step 4: Lock the endpoint down
A webhook URL is a door that accepts instructions. If anyone learns the address, they can send your receiver a “buy” of their own. Three layers keep that door shut, and you should use more than one.
Allowlist TradingView’s four addresses. If your server or a bridge lets you restrict inbound traffic by source IP, allow only the four IPs listed above. Some bridges offer this as a ready setting, with a “TradingView servers only” option. Re-read TradingView’s help page every so often, because the list is theirs to change.
Put a shared secret inside the payload. TradingView gives you no field for custom headers, so you cannot add an Authorization header. The usual substitute is a long random string in the message, such as the "key" field in the example above, which your receiver compares against its own copy and rejects on a mismatch. Treat it like a password you can rotate: if it ever leaks, change it in both places and recreate the alerts.
Never put credentials in the message or the URL. TradingView’s own help page is blunt about this: do not include login credentials or passwords in the webhook URL or message. A shared token that only your receiver understands is a different thing from a broker password or an exchange API secret. The broker keys belong on the receiving side, in its settings, and never travel in an alert.
Also use an HTTPS address even though port 80 is accepted. Port 80 sends the message, and your shared secret with it, in the clear.
Step 5: Test before connecting real order execution
Before pointing a webhook at anything that touches real capital, confirm the payload arrives correctly and parses as expected. A dedicated webhook-testing utility (there are several free request-catcher tools built exactly for this) gives you a temporary URL that logs every incoming request, including the headers and the raw body.
TradingView has no “send test” button for webhooks, so you test by making a real alert fire. The practical way is a throwaway alert on a liquid symbol on a one-minute chart, with a condition that will trip within a few minutes (a price crossing a level just above or below the current price works). Point it at the testing URL, wait for it to fire, then delete the alert so it does not keep sending. When you test a strategy alert, remember that its placeholders only fill when the strategy actually executes an order.
When the request lands, check four things:
- The content type.
application/jsonmeans TradingView read your message as valid JSON.text/plainmeans something in it is broken. - The raw body. Read what arrived, not what you typed. Every placeholder should be replaced by a real value, with no empty fields and no leftover curly braces.
- The arrival time against
{{timenow}}. This is your first real measurement of delay. - TradingView’s alert log. Open the alert log and look at the Webhook status column. It tells you whether TradingView believes the delivery succeeded. If the alert is missing from the log altogether, the problem is on the TradingView side (the condition, the chart, the trigger), not in your receiver.
This step catches the two most common webhook setup mistakes before they cost money:
- Malformed JSON. A missing comma, an unescaped quote, a leftover line of default text, or a variable placeholder typo produces a payload the receiving service can’t parse — and TradingView will not warn you about this at alert-creation time. It simply sends the text as
text/plainand leaves your receiver to cope. - Wrong or unresolved variables. A placeholder that doesn’t exist for the alert type you configured (using a strategy placeholder on a plain indicator alert, for example) resolves to an empty string or literal text instead of a value, silently corrupting every downstream field that depends on it.
Only after confirming clean, correctly-parsed test payloads should you switch the webhook URL from the testing tool to your live bridge or broker endpoint.
Host your own receiver (optional)
If you went down Path D, here is the smallest receiver we would trust to sit behind a webhook. It checks the secret, ignores repeats, and answers straight away. It is a teaching sketch, not a finished product, and it does not place any orders.
import hmac
import os
from flask import Flask, request, abort
app = Flask(__name__)
SECRET = os.environ["TV_SECRET"] # keep it out of the code
seen = set() # use a database table in real use
@app.post("/tv")
def tv():
data = request.get_json(silent=True)
if not data:
abort(400) # TradingView sent text/plain, so the JSON was broken
if not hmac.compare_digest(str(data.get("key", "")), SECRET):
abort(403) # wrong or missing secret
uid = f'{data.get("symbol")}|{data.get("action")}|{data.get("sent_at")}'
if uid in seen:
return "duplicate", 200 # same alert twice, do nothing
seen.add(uid)
# push the signal onto a queue here; do NOT call the broker inline
return "ok", 200
The shape matters more than the language. Check the secret first, make the repeat check cheap, hand the real work to a queue or worker, and return 200 inside the three-second window. Run it behind a reverse proxy with an HTTPS certificate on port 443, and keep a log of every request, accepted or rejected, because that log is what you will read at 2am when something looks off.
Step 6: Add safety layers before going fully live
An automated pipeline that places real orders with no human in the loop needs guardrails a manual-alert setup never required, because there’s no longer a person double-checking the signal before it becomes a trade. Paper trade first. A webhook carries out a plan you have already tested. It is not a reason to skip the testing.
Position-size caps at the receiving end, not just in your indicator’s logic. Most bridges and broker APIs let you set a maximum order size independent of whatever quantity the webhook payload requests. Set this even if your JSON payload already specifies a fixed size — it’s a second, independent check that catches a malformed payload requesting an unintended quantity before it reaches your broker.
A dry-run or paper-trading mode for the first live cycle. Many bridges support a test mode that logs the intended order without actually submitting it, or routes to a paper-trading account instead of a live one. Run your full alert-to-execution pipeline in this mode through at least a handful of real signals before flipping it to live capital — this surfaces timing issues, payload mismatches, or broker-side rejections in an environment where a mistake costs nothing.
An alert-delivery monitor. TradingView alerts can silently stop under specific conditions — the alert expired (two months on Essential and Plus), the account was downgraded, or the alert fired more than 15 times in three minutes and was switched off — and a webhook delivery itself can fail if your receiving endpoint is temporarily down or slow. Most bridge platforms log delivery success/failure and can notify you (separately, via email or Telegram) if an expected webhook wasn’t received — set this up before relying on the pipeline for real trades, because the most dangerous failure mode in automation isn’t a wrong trade, it’s a missed one you don’t find out about until you check your account balance.
A duplicate guard and a rate limit. Retries and duplicate alert definitions both exist. Decide in advance what your receiver does when the same instruction arrives twice, and cap how many orders it will accept per minute.
Expect delay, and size for it. Independent bridge vendors report delivery anywhere from a couple of seconds to roughly a minute at busy moments, such as the top of the hour and session opens. An alert set to fire on bar close can also land a little after the bar ends. A webhook is fast compared with a human reaching for a phone, but it is not tick-by-tick execution, and a strategy whose edge disappears in a few seconds of slippage should not be automated this way. Our piece on why backtests don’t match live trading covers how that gap shows up in real results, and the glossary entry on slippage explains the cost side.
Webhook not firing or not arriving? A checklist
Work down the chain in this order. TradingView first, then the network, then your receiver.
| Symptom | Likely cause | What to do |
|---|---|---|
| The Webhook URL box will not tick | 2FA is off, or you are on the free Basic plan | Switch on two-factor authentication, then check your plan |
| The alert is not in the alert log at all | The condition never triggered, the alert is on the wrong chart, or it expired | Check the symbol and timeframe, the trigger, and the expiry date, then recreate it |
| The alert fired and the log shows a webhook failure | Port other than 80/443, IPv6-only server, a URL typo, or a reply slower than three seconds | Fix the URL, then make the receiver answer first and work afterwards |
| The alert stopped after a busy spell | More than 15 triggers in 3 minutes | Change the trigger to bar close, or reduce what fires the alert |
| Everything worked, then stopped weeks later | The alert expired, or the account was downgraded | Recreate the alert on the current plan and set a reminder |
| The receiver rejects the message | Broken JSON, so it arrived as text/plain, or the wrong field names | Look at the raw body in the test tool and fix the quotes and commas |
| Fields are empty or zero | A strategy placeholder on an indicator alert, or a placeholder typo | Match placeholders to the alert type |
| Behaviour differs from the strategy you just edited | A strategy alert keeps the inputs it was created with | Delete the alert and create a new one |
| A 403 from your own server | The firewall is blocking TradingView’s addresses | Allowlist the four IPs |
| The same order appears twice | Duplicate alert definitions or a repeat delivery | Add a duplicate guard on the receiver |
| It works from a test tool but not from your server | The server is not publicly reachable, or sits on a blocked port | Use a public address on 80 or 443 |
If you reach the end of this list and still cannot see where it breaks, send the same payload to a plain request-catcher and compare it with what your receiver gets. The difference is usually obvious in the headers.
Common mistakes when setting up TradingView webhooks
Triggering on “Once Per Bar” instead of “Once Per Bar Close.” This is the single most common configuration error and it directly undermines non-repainting confirmation — the alert fires on every intrabar update rather than waiting for the bar (and the indicator’s signal) to actually confirm.
Hardcoding values instead of using TradingView’s dynamic variables. A payload with a literal symbol and price baked in only works for the one instrument and moment you wrote it for. Using {{ticker}}, {{close}}, and related placeholders makes one alert template reusable across your entire watchlist.
Skipping the test-payload step. Going straight from “alert created” to “connected to live broker” means the first time you discover a malformed JSON payload is when a real order fails to place — or worse, places incorrectly.
No position-size cap independent of the payload. If the only thing limiting order size is what the JSON payload says, a single bad alert (or a bug in a bridge’s parsing) has no second line of defense before it reaches your broker.
Assuming webhook delivery is guaranteed. Webhooks are delivered on a best-effort basis over the internet — network issues, an expired API key on the receiving end, or a temporarily down endpoint can all cause a webhook to never arrive, with TradingView giving no retry guarantee for most alert types. A monitored pipeline catches this; an unmonitored one just quietly stops trading and you may not notice for hours.
Forgetting the alert has an end date. An Essential or Plus alert is gone after two months. The pipeline looks healthy right up to the day it stops.
Leaving the default message text in the box. A stray line above your JSON means the whole message is no longer valid JSON, so the request goes out as plain text.
Pasting a secret into a message you also share. If you screenshot your alert for a forum post or a support ticket, the shared key goes with it. Crop it out, or rotate it afterwards.
Webhook automation and your existing indicator stack
Webhook alerts work identically whether you’re automating a single indicator’s signal or a full confluence stack — the alert condition on TradingView’s side can be set on a combined Pine Script condition (all layers of your stack agreeing) just as easily as on a single indicator’s plot. If you’re running a multi-layer confluence system, build the combined condition into a single Pine Script alert condition first (rather than firing three separate webhooks per layer that your receiving end then has to reconcile), so the webhook only fires once the full setup — trend filter, momentum trigger, and volume/location confirmation — has actually qualified. This keeps the automation logic matching exactly what you backtested, rather than introducing a new point of divergence between your tested strategy and what actually executes. If you write that combined condition in Pine Script yourself, our note on reading TradingView’s Pine Script documentation and the Pine Script glossary entry are good places to start, and our Pine Editor guide covers the errors you will hit first.
Webhooks are one way to act on an alert, not the only one. If you would rather keep the final decision with a person and still stay off the screen, the mobile alert workflow shows how push alerts and a short decision checklist cover most of the same ground, and how to copy trade on TradingView covers the route where a second account mirrors the first.
Frequently Asked Questions
Quantzee provides analytical software, not investment advice. Test everything in a non-live environment first, and treat any automated order as your own responsibility.
