You built a strategy on TradingView. It fires alerts. You watch. You click. You switch to your broker’s terminal. You enter the trade manually. By the time you’re done, the price has already moved.
This is where most automation stories begin — and where most traders get stuck. They hear “webhook” and assume it’s developer territory. JSON, endpoints, HTTP POST requests. It sounds like backend engineering, not trading.
It’s not. A webhook is the simplest piece of the automation puzzle. Understanding what it does — and what it doesn’t — takes five minutes. Those five minutes decide whether you automate your execution or keep copy-pasting alerts into a terminal window.
A webhook is a message that TradingView sends to an external URL the moment an alert fires.
That’s it. No polling. No refreshing. No manual check. Your alert condition triggers, and TradingView immediately sends an HTTP POST request — a small packet of data — to whatever URL you specified. The receiving server reads the message and acts on it.
Think of it as a text message from TradingView to another computer. “Hey, the condition you set on EURUSD just triggered. Here’s what happened.” The receiving computer decides what to do with that information.
The entire chain from chart event to webhook delivery has four stages.
TradingView’s servers continuously check your alert conditions against incoming market data. When a condition is met — a price cross, an indicator signal, a strategy entry — the system flags it. This stage takes 25–100ms under normal conditions.
TradingView constructs an HTTP POST request and sends it to the URL you entered. The request body contains whatever text you put in the “Message” field. If it’s valid JSON, the content-type is application/json. Takes 50–300ms normally, up to 500ms–2s during major events.
Your trade copier, custom bot, or automation platform receives the POST request. It parses the message, validates it, and decides what to do. If the server doesn’t respond within 3 seconds, TradingView cancels the request.
The receiving system executes its programmed logic. Place a trade. Send a notification. Log the signal. This part is entirely on the receiving end — TradingView’s job is done.
End-to-end, from candle close to webhook arrival, the typical time is 200–800ms under normal market conditions. During high-volume events like Non-Farm Payrolls or FOMC announcements, expect 500ms–2s.
The webhook sends exactly what you put in the alert’s “Message” field. Nothing more, nothing less.
TradingView doesn’t automatically include the symbol name, the price, the timeframe, or the action. If you want those in the message, you write them in — either as static text or using TradingView’s built-in placeholder variables.
A simple plain-text message might look like this:
A structured JSON message for an automation platform might look like this:
The double-brace variables ({{close}}, {{timenow}}, {{ticker}}) are TradingView placeholders that get replaced with actual values when the alert fires.
This is where the concept splits into two worlds. If you’re connecting to a system that reads JSON — most custom bots, many third-party platforms — you need to format the message correctly. One missing comma, one unclosed bracket, and the receiving system can’t parse it.
If you’re connecting to a system designed to work without manual message formatting — like Nordman Connector’s No-Code workflow — the webhook message comes pre-built. You copy it from the client area, paste it into the alert. No JSON editing. No placeholder debugging.
Three requirements. Miss any one, and the webhook won’t fire.
Webhooks look simple until they stop working. Here’s where they break.
Every webhook-based system adds latency to your execution. The question is whether that latency matters for your strategy.
According to measurements published by ClearEdge Trading, the full execution chain — from alert trigger through broker fill — typically takes 1–5 seconds under normal market conditions. Breaking that down:
| Stage | Normal | During Events |
|---|---|---|
| Alert detection (TradingView) | 25–100ms | 200–1,000ms |
| Webhook dispatch (TradingView) | 50–300ms | 500–2,000ms |
| Platform processing (copier) | 3–50ms | 50–200ms |
| Broker execution | 50–500ms | 500–5,000ms |
The webhook dispatch — TradingView’s part — is typically the largest single contributor. It’s also the one you have the least control over. Your TradingView plan tier affects it (Premium plans tend to deliver faster), but you can’t eliminate the delay.
For ES futures during fast market conditions, ClearEdge estimates that each second of latency produces 1–2 ticks of slippage per contract. On quiet midday sessions, latency is mostly irrelevant.
The practical takeaway: if your strategy targets moves of 20+ ticks and holds for minutes, webhook latency is noise. If you’re scalping 3-tick moves on ES during the open, the execution chain matters more than the strategy.
A webhook by itself does nothing. It’s a delivery mechanism — a way to get a message from point A to point B.
The real question is what happens at point B. And that’s where the architecture of your copier determines whether the webhook actually results in a trade.
Most webhook-based copiers work like this: receive the JSON message, parse the symbol name, look up the symbol in the broker’s catalog (symbol mapping), translate the lot size, and submit the order. Every one of those steps is a potential failure point.
Nordman Connector uses the webhook as a trigger, not as a full instruction set. The Receiver — our terminal-side component — is already attached to the chart of the instrument you want to trade. When the webhook arrives, the Receiver doesn’t need to parse a symbol name or look up a mapping table. It executes on the chart it’s sitting on.
This means the webhook message doesn’t need to carry the symbol, the lot size, or the execution parameters. Those are configured on the terminal side, in the Receiver’s settings. The webhook says “go.” The Receiver already knows where and how.
More detail on connecting TradingView to multiple terminals without code: Can You Connect TradingView to MT4, MT5, and NinjaTrader 8?
Webhooks are the right tool if you have a strategy on TradingView — manual or automated — and you want it to execute on an external terminal without you sitting at the screen.
Nordman Connector is not for you if you don’t use TradingView — cross-terminal copiers exist for that workflow. It’s not for you if you expect zero latency — webhooks add 200ms–2s to your execution, and if your strategy can’t absorb that, you need co-located execution, not a webhook. And it’s not for you if your broker is in a different region from our infrastructure (Frankfurt) — the additional network hop adds latency on top of TradingView’s dispatch delay. If any of those describe you — this article was interesting, close the tab, don’t spend €25 with us.
A walkthrough of how this looks in practice:
Need something custom built? We develop automation to order — learn more.
Nordman Algorithms provides software infrastructure for trade automation and does not offer financial advice, trading signals, or managed trading services. This article is for informational and educational purposes only. Trading leveraged instruments such as Forex and CFDs carries a high level of risk and may not be suitable for all investors — only risk capital should be used. Full Risk Disclosure: https://www.nordman-algorithms.com/risk-disclosure/
