Skip to content
70% OFF Black Friday Sale Biggest Indicator Sale of the Year. 148 left Get QuantZee →
Back to Blog
Alert AutomationTradingView AlertsNon-Repainting

TradingView Alerts to Webhook: A No-Code Setup Guide for Any Broker

By Rajeev Gupta · · 22 min read

Originally published

TradingView alerts to webhook setup diagram: a candlestick chart alert on a laptop sends a webhook URL and JSON message to webhook middleware, which routes it to automated broker actions, email notifications and integrated platforms via API

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.

RequirementWhat TradingView saysWhat it means for you
Paid planThe free Basic plan has no webhook notificationsYou need Essential, Plus, Premium or Ultimate
Two-factor authenticationWebhook 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
PortsOnly 80 and 443 are acceptedA URL like https://example.com:8443/hook is rejected before it leaves TradingView
Response timeA request is cancelled if the server takes longer than three secondsAnswer first, do the slow work afterwards
IP versionIPv6 is not supportedYour endpoint must be reachable over IPv4
Sending addressesFour fixed IPs52.89.214.238, 34.212.75.30, 54.218.53.128, 52.32.178.7 — allowlist these if your server sits behind a firewall
DeliveryWebhooks “may occasionally fail” to reach the URLWatch 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:

PlanList price, billed monthly (USD)Billed yearly, per month (USD)Price alertsTechnical (indicator and strategy) alertsAlert lifetime
BasicFreeFree3None listed1 month
Essential$14.95$12.9520202 months
Plus$34.95$29.951001002 months
Premium$69.95$59.95400400Open-ended option
Ultimate$239.95$199.951,0001,000Open-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

TradingView Create alert dialog on a BTCUSD 1-hour chart with the Condition, Trigger, Expiration, Message and Notifications fields visible and the Alert button in the top toolbar marked with an arrow

Start from the chart with your indicator or strategy applied.

  1. Click the Alert icon (clock icon) in the right-hand toolbar, or right-click the chart and select “Add Alert.”
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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

Illustration titled Choose where the webhook sends data, showing a webhook plug icon linked to a server and database on the left and three cloud icons on the right for the broker, bridge and automation platform destinations

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

Graphic titled Build the JSON payload TradingView sends, with the text framed by curly braces over a blurred TradingView chart

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.

PlaceholderWhat 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:

PlaceholderWhat 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

Graphic titled Test before connecting real order execution, with a test tube, sandbox, shield with a tick and warning sign icons over a candlestick chart

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:

  1. The content type. application/json means TradingView read your message as valid JSON. text/plain means something in it is broken.
  2. 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.
  3. The arrival time against {{timenow}}. This is your first real measurement of delay.
  4. 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:

  1. 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/plain and leaves your receiver to cope.
  2. 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

Illustration titled Add safety layers before going fully live, showing three stacked shield layers with a padlock on top over a dark candlestick chart

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.

SymptomLikely causeWhat to do
The Webhook URL box will not tick2FA is off, or you are on the free Basic planSwitch on two-factor authentication, then check your plan
The alert is not in the alert log at allThe condition never triggered, the alert is on the wrong chart, or it expiredCheck the symbol and timeframe, the trigger, and the expiry date, then recreate it
The alert fired and the log shows a webhook failurePort other than 80/443, IPv6-only server, a URL typo, or a reply slower than three secondsFix the URL, then make the receiver answer first and work afterwards
The alert stopped after a busy spellMore than 15 triggers in 3 minutesChange the trigger to bar close, or reduce what fires the alert
Everything worked, then stopped weeks laterThe alert expired, or the account was downgradedRecreate the alert on the current plan and set a reminder
The receiver rejects the messageBroken JSON, so it arrived as text/plain, or the wrong field namesLook at the raw body in the test tool and fix the quotes and commas
Fields are empty or zeroA strategy placeholder on an indicator alert, or a placeholder typoMatch placeholders to the alert type
Behaviour differs from the strategy you just editedA strategy alert keeps the inputs it was created withDelete the alert and create a new one
A 403 from your own serverThe firewall is blocking TradingView’s addressesAllowlist the four IPs
The same order appears twiceDuplicate alert definitions or a repeat deliveryAdd a duplicate guard on the receiver
It works from a test tool but not from your serverThe server is not publicly reachable, or sits on a blocked portUse 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

Graphic titled Common mistakes when setting up TradingView webhooks, surrounded by warning, broken link, unplugged cable, settings gear and alert bell icons

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

Do I need to know how to code to set up a TradingView webhook?
No. Creating a webhook alert on TradingView is entirely point-and-click — you paste a URL and a JSON message template into the alert dialog. Coding is only needed if you choose to build your own custom receiving server; using a no-code bridge platform or a broker with native webhook support avoids any coding on the receiving end too.
What TradingView plan do I need for webhook alerts?
You need a paid plan. The free Basic plan has no webhook notifications. The paid plans today are Essential, Plus, Premium and Ultimate (the older Pro, Pro+ and Expert names have been retired), and the independent guides we compared list webhooks on all four, so check the "Webhook notifications" row on TradingView's pricing page before you buy. Your account also needs two-factor authentication switched on. As a list price in US dollars, Essential is $14.95 a month billed monthly and Ultimate is $239.95, with yearly billing cheaper.
Why can't I tick the Webhook URL box?
Almost always one of two reasons. TradingView only allows webhook alerts when two-factor authentication is enabled on your account, and the free Basic plan does not include webhooks. Turn on 2FA in your account security settings, check your plan, then try again.
Which ports and IP addresses does TradingView use for webhooks?
TradingView only sends to ports 80 and 443, so a URL on any other port is rejected. It sends from four IPv4 addresses, 52.89.214.238, 34.212.75.30, 54.218.53.128 and 52.32.178.7, which you can allowlist on a firewall. IPv6 is not supported. Check TradingView's help page for the current list before you rely on it.
How long does my server have to respond to a TradingView webhook?
Three seconds. If the server takes longer, TradingView cancels the request and the delivery shows as failed in the alert log, even if your server went on to process it. Reply immediately and do the slow work, such as talking to a broker, after you have answered.
Can I connect a TradingView webhook directly to any broker?
Only if that broker natively supports TradingView webhooks or exposes an API a no-code bridge platform already integrates with. If your broker supports neither, a webhook-to-broker bridge tool is the standard no-code path — it receives the TradingView payload and translates it into that broker's specific API calls.
Why does my webhook alert fire on every candle instead of once per signal?
This almost always means the alert's trigger setting is "Once Per Bar" instead of "Once Per Bar Close." Once Per Bar fires on every intrabar price update, including values that haven't confirmed yet — switch to Once Per Bar Close so the alert only fires after the bar, and the underlying signal, has actually confirmed.
Is it safe to fully automate trade execution from TradingView alerts?
It can be, but only with safety layers most first-time setups skip: a position-size cap independent of the alert payload, a paper-trading or dry-run test period before going live, and a monitor that flags if an expected webhook fails to arrive. TradingView itself says its alerts are not designed for automated trading, and delivery is best-effort, so automation removes the human check that would normally catch a malformed signal and those checks need to exist somewhere else in the pipeline.
Can I use webhooks with a non-repainting indicator to fully automate my strategy?
Yes, and this is the primary use case webhooks unlock — a non-repainting indicator's signal is stable the moment it confirms on bar close, which is exactly the event a "Once Per Bar Close" webhook alert fires on. Pairing a webhook with a repainting indicator is riskier, because the automation could execute on a signal position that later shifts.
What's the difference between a webhook alert and a regular TradingView notification?
Regular notifications (app push, email, SMS, pop-up) are designed for a human to read and then manually act on. A webhook sends the alert's message as structured data (typically JSON) directly to a URL, letting a broker, bot, or automation platform act on it immediately without any human in the loop.
How do I connect a TradingView alert to a webhook?
Turn on two-factor authentication, then create an alert, open the Notifications tab, check "Webhook URL," paste your receiving endpoint's URL on port 80 or 443 (HTTPS is better), then define a JSON payload in the alert's Message field using TradingView's placeholder variables. Test the connection with a throwaway alert before relying on it live.
What JSON format does TradingView send to a webhook?
TradingView sends whatever you write in the alert's Message field, with placeholder variables like {{ticker}}, {{close}}, and {{timenow}} swapped for live values when the alert fires. There is no fixed default format and no required field. If the message is valid JSON the request goes out as application/json; if not, it goes out as text/plain.
Why is my TradingView webhook not firing?
Work down the chain. First check 2FA and your plan, then the alert log: is the alert listed, and what does the Webhook status column say? Then look for an expired alert, a wrong chart, a port other than 80 or 443, a reply slower than three seconds, or malformed JSON. TradingView also stops an alert that triggers more than 15 times in three minutes. The checklist table above covers each case.
Does TradingView send webhooks as JSON or plain text?
Both, depending on your message. A message that is valid JSON is sent with an application/json content type. Anything else is sent as text/plain. You cannot choose the header yourself, which is why a stray comma can turn a good payload into plain text.
How many TradingView alerts do I need for one webhook strategy?
A strategy usually needs one alert per chart (one symbol and one timeframe), because the same alert carries entries and exits. A plain indicator usually needs two, one for buy and one for sell. Essential allows 20 technical alerts, Plus 100, Premium 400 and Ultimate 1,000.
How long does a TradingView webhook alert last?
On Essential and Plus an alert runs for at most two months and then stops without sending anything to your broker. Premium and Ultimate offer open-ended alerts, which are still switched off if they have neither fired nor been edited for a year. Put the expiry date in a calendar.
Can I send one TradingView alert to two webhook URLs?
No. An alert has a single webhook URL field. To reach more than one destination, point the alert at a relay or at your own server and let that forward the message on.
Can I use localhost or a home computer as the webhook URL?
Not directly. TradingView sends from its own servers, so the URL must be reachable from the public internet on port 80 or 443. For testing you can use a tunnelling tool or a small cloud server; for live use, a properly secured public address.
How do I keep my webhook URL secure?
Allowlist TradingView's four IP addresses if you can, use HTTPS, and put a long random shared key in the JSON message that your receiver checks. TradingView gives you no field for custom headers, so the key has to travel in the message. Never put broker passwords or exchange API secrets in a webhook URL or message.

Quantzee provides analytical software, not investment advice. Test everything in a non-live environment first, and treat any automated order as your own responsibility.

FAQ

Frequently Asked Questions

No. Creating a webhook alert on TradingView is entirely point-and-click — you paste a URL and a JSON message template into the alert dialog. Coding is only needed if you choose to build your own custom receiving server; using a no-code bridge platform or a broker with native webhook support avoids any coding on the receiving end too.

Put It Into Practice

Try Quantzee's AI-Powered Indicators

Non-repainting signals, real-time alerts, all markets.

Get Quantzee
Rajeev Gupta, Founder & CEO of Quantzee

Written By

Rajeev Gupta

Founder & CEO, Quantzee

Rajeev Gupta is a Commerce Graduate with a Masters in Business Administration (Finance), and has been trading the markets since 1997. He previously worked with Religare Securities Limited as Head – Private Client Group until 2006, after which he started his own broking firm. He went on to found and lead Quantzee, where his focus has stayed on quantitative trading strategies — volatility dynamics, intraday price behavior, and regime-aware signal design. Every indicator in the Quantzee suite is derived from the methodology he uses in his own live trading account.