TradingView webhook alerts guide to your first live signal

You've got a Pine Script strategy that looks good on the chart. The backtest is green. Now you want it trading on your broker account while you sleep. A webhook alert is the piece that makes that happen, and it's easier to set up than most YouTube tutorials suggest.

This is the part where most traders get stuck: not because webhooks are hard, but because nobody explains the full chain in one place. Your strategy fires an alert. The alert sends an HTTP request to a URL you specify. The server at that URL reads the message you attached and does something with it, like forwarding it to your broker as a real trade.

That's the entire concept. The rest is details.

What a webhook actually does

A TradingView webhook is an HTTP POST request. When your alert triggers, TradingView's servers send a small packet of data to whatever URL you've pasted into the alert's webhook field. The packet contains whatever text you wrote in the "Message" box of that alert.

That's it. TradingView doesn't know or care what's on the other end of that URL. It could be a trading bridge, a Telegram bot, a Google Sheet, or a server you built yourself. TradingView's job ends at "send the message." What happens after that is up to the receiving server.

This means two things. First, the webhook message format matters a lot, because the receiving server needs to understand what you sent. Second, if the receiving server is down or slow, your alert still fired on TradingView's end, but nothing happened on the other side. There's no automatic retry that you can count on.

What you need before you start

Three things, and one of them trips up more people than you'd expect.

A TradingView Essential plan (or higher). Webhooks are not available on the free plan. This catches many first-time automators off guard. You'll build your strategy, set up your alert, and then discover the webhook URL field is grayed out.

The Essential plan is the minimum. It costs $14.95/month (billed annually) at the time of writing. No workaround exists.

A Pine Script strategy with alert conditions. Your script needs to generate alerts. If you're using a strategy() script, TradingView can automatically fire alerts on order fills. If you're using an indicator() with alertcondition(), you'll need to define when alerts fire yourself. Either works. The difference matters for what ends up in your alert message, which we'll get to.

A destination URL. Something has to receive the webhook. If you're connecting to a broker, you'll typically use a bridge service that gives you a personal URL. DIY is an option too, but it means running your own server with a public endpoint that accepts POST requests. For most traders, the bridge route saves weeks of debugging.

How to set up TradingView webhook alerts step by step

Open your chart with your strategy loaded. Configuring TradingView webhook alerts takes about 5 minutes once you know where everything is.

Step 1: Open the alert dialog. Click the "Alerts" icon in the right panel (the clock with a plus sign), or right-click on your chart and select "Add Alert." If your strategy is loaded on the chart, you'll see it as an option in the "Condition" dropdown.

Step 2: Set the condition. For a strategy() script, select your strategy name and set the condition to "Order fills only." This fires the alert every time your strategy generates a buy or sell order. For an indicator(), select the specific alertcondition() you defined in your script.

Step 3: Enable the webhook URL. Scroll down in the alert dialog. You'll see a "Webhook URL" checkbox. Check it. A text field appears. Paste your destination URL here.

This is the URL that TradingView will POST to every time this alert triggers. If the checkbox is grayed out, your plan doesn't support webhooks. Upgrade to Essential.

Step 4: Write the alert message. This is where most problems start, and where most guides are too vague. The "Message" field is the payload that gets sent to your webhook URL. It's the instruction set that tells the receiving server what trade to place, not a notification to yourself. We'll cover the format in the next section.

Step 5: Set alert expiration and save. TradingView alerts expire. The default is usually a few months, but check. An expired alert is silent. "My strategy stopped trading three weeks ago, and I didn't notice" is a real failure mode, and it happens more than you'd think. Set expiration to the maximum your plan allows, and calendar-remind yourself to renew.

How to configure your alert payload

The alert message is where your TradingView strategy communicates with your broker (through whatever bridge or server sits between). Get the format wrong, and nothing trades. Get it right once, and every future strategy uses the same pattern.

TradingView gives you built-in placeholders that auto-fill with live data when the alert fires. The useful ones for trading are:

• {{strategy.order.action}}: "buy" or "sell"
• {{ticker}}: the symbol, like "EURUSD" or "XAUUSD"
• {{strategy.order.price}}: the price at which the strategy order triggered
• {{strategy.position_size}}: current position size after the order
• {{close}}: the closing price of the bar that triggered the alert

A basic alert message for a bridge might look like this:

{{strategy.order.action}},{{ticker}},price={{close}},sl=50,tp=100

The exact format depends entirely on what your receiving server expects. Every bridge has its own spec. Some expect JSON, others expect comma-separated values, and others expect a custom key-value format.

Check your bridge's documentation for the exact template before you write anything. One wrong field and the trade won't fire.

Common mistakes that break alert payloads:

Typos in placeholder names. {{strategy.order.action}} works. {{strategy.order.Action}} doesn't. TradingView won't warn you; it'll just send the literal text with the curly braces instead of the actual value.

Assuming the message carries over when you edit the script. It doesn't. If you change your Pine Script and re-save, TradingView does not update existing alerts. You need to delete the old alert and create a new one with the updated message. This is the single most common "my strategy changed, but my trades didn't" bug.

Sending the wrong symbol format. Your TradingView chart might show "EURUSD," but your broker might expect "EUR/USD" or "EURUSD.pro" or something else entirely. The {{ticker}} placeholder sends whatever TradingView calls the symbol, which may not match your broker's naming conventions. Most bridges handle this using a symbol-mapping table. Set it up before your first live signal, not after.

TradingView webhook timeout: the 10-second limit

TradingView gives the receiving server roughly 10 seconds to respond to a webhook. If the server doesn't send back an HTTP 200 (success) within that window, TradingView marks the webhook as failed.

This matters because a failed webhook means your trade didn't reach the bridge. Your strategy fired. TradingView sent the POST. But the other end didn't confirm receipt in time, so from TradingView's side, it's a dead letter.

The most common cause of timeouts is a slow or overloaded receiving server. If you're running your own VPS with a Python script that also handles order execution synchronously (send order, wait for broker confirmation, then respond to TradingView), you can easily blow past 10 seconds on a volatile bar when your broker is slow to fill. The fix is architectural: your server should acknowledge the webhook immediately and process the trade asynchronously.

If you're using a bridge service, timeouts are the bridge's problem to solve. But you should still know they exist, because when a trade doesn't appear on your account, "did TradingView's webhook alert time out?" is one of the first questions to ask. TradingView shows webhook delivery status in the alert log. Check there.

One more thing on the topic of webhook timeout seconds: TradingView doesn't retry failed webhooks reliably. Some traders assume a timeout means the alert will fire again. It usually won't. A missed webhook is a missed trade unless your bridge has its own retry logic or you're actively monitoring the pipeline.

When your webhook doesn't fire: common failures

A configured webhook alert that doesn't produce a trade on your broker account could be failing at any of four points. Knowing which one saves you from changing the wrong thing.

The alert didn't trigger. Your strategy conditions weren't met on the current bar. Or the alert expired. Or you edited your script and didn't recreate the alert.

Open the TradingView Alerts panel and check whether the alert shows a recent trigger timestamp. No timestamp, no webhook, no trade. This is also a common issue when TradingView alerts are not working as expected. Always verify the alert itself before blaming the webhook.

The webhook was sent, but the server rejected it. TradingView shows a webhook delivery status for each alert trigger. Look for "webhook failed" or an HTTP error code (anything other than 200). That means the receiving server got your request and rejected it. Usually, a malformed payload. Copy your alert message, paste it into your bridge's test tool if it has one, and see what breaks.

The server received it, but the trade failed at the broker. The webhook arrived, the bridge parsed it, and the order went to your broker. Rejected. Market closed, insufficient margin, invalid symbol, lot size out of range. This failure is invisible to TradingView because the webhook succeeded. You need your bridge's logs or your broker's journal to find it.

The trade executed but not the way you expected. The order went through, but the fill price is different from what your strategy showed, or the stop-loss is off by a few points. This isn't a webhook failure. It's live execution reality: spread, slippage, and requotes. If you're running prop-firm evaluations, even a small SL drift can cost you a passing score. Traders looking for the best trade copier for TradingView often discover that a copier alone doesn't fix this, because copiers forward signals without verifying the fill.

TradingView webhook alerts with FillEdge: setup in 15 minutes

FillEdge is an execution bridge that takes TradingView alerts and turns them into verified trades on your broker account. The setup is built specifically to eliminate the failure points described above.

When you create a FillEdge account, you get a personal webhook URL. One URL, permanent, works for every strategy you'll ever connect. Paste it into TradingView's webhook field and that step is done forever.

The part that usually wastes the most time (writing the alert message format) is handled by FillEdge's alert template builder. Open it in the dashboard, pick your strategy tag, your destination account, and your command type (buy, sell, close, reverse). The builder generates a copy-paste-ready message string.

Put it in TradingView's alert message box. Done. No guessing at placeholder syntax, no JSON formatting errors, no symbol mapping headaches.

Before you go live, FillEdge lets you send a test signal through the full pipeline. Hit the test button in the dashboard and watch the signal travel: webhook received, signal parsed, routed to your account, picked up by the Expert Advisor in your terminal, acknowledged back.

Every stage gets a timestamp and a status. If something fails, the pipeline visualization shows you exactly which stage broke and why, in plain language. Not a generic error code. A sentence that tells you what to fix.

Once you're live, every signal that travels through FillEdge is reconciled.

The bridge compares what TradingView sent with what your broker actually did. If the two match, the signal gets a ✓MATCHED badge. If your stop-loss landed exactly where your strategy calculated, it gets 🎯LOCKED.

Duplicate alert tried to sneak through? FillEdge catches it before it reaches your broker (👻CAUGHT). Reversal arrived out of order? The bridge sequences the close before the open (🔀REORDERED). You see all of this in the signal log, not buried in server logs you'll never read.

Every trade is journaled automatically: the TradingView signal that fired it, the broker fill that resulted, the slippage between the two, and the latency from alert to execution. No spreadsheets, no CSV exports, no manual entries. You can also route one TradingView alert to multiple broker accounts at different lot sizes with a signal multiplier, if you're running more than one account.

The whole setup, from signup to first test signal completing the full pipeline, takes about 15 minutes. That includes installing the EA on your terminal, connecting it to FillEdge, building your first alert template, and sending the test.

No MQL5 required. FillEdge runs the infrastructure. You run the strategy.

For traders building their first TradingView automated trading setup, this is the fastest path from "I have a strategy on a chart" to "it's trading on my broker account, and I can prove the fills match." The kind of proof you'd want before running a prop-firm evaluation or a live account with real capital.

Traders who want to understand TradingView automated trading features in more depth before choosing an automation path will find that webhooks are the most flexible entry point, because they don't require you to rewrite anything in MQL5 or learn a second scripting language. And if you're evaluating whether a bridge fits your workflow or whether you'd prefer to connect a broker to TradingView through native integrations, here's the short version: native integrations don't cover most brokers, and webhooks do.

Your Pine Script stays where it is. The webhook carries the signal. The bridge handles the rest.

FAQ

What happens when a TradingView webhook times out?

TradingView gives the receiving server roughly 10 seconds to respond with an HTTP 200 status. If it doesn't, TradingView marks the webhook as failed and moves on. The alert itself still shows as triggered in your alert log, but the payload never reached its destination successfully. TradingView does not reliably retry failed webhooks, so a timeout usually means a missed trade unless your bridge has its own retry logic.

What format should my TradingView webhook alert message be in?

The format depends entirely on what's receiving the webhook. Some bridges expect comma-separated values, some expect JSON, some have their own key-value syntax. TradingView provides built-in placeholders like {{strategy.order.action}}, {{ticker}}, and {{close}} that auto-fill when the alert fires. Check your bridge's documentation for the exact template it expects, and use TradingView's placeholders to populate the fields. A typo in a placeholder name (like capitalizing "Action" instead of "action") will send the raw text instead of the live value, and TradingView won't warn you.

How do I test if my TradingView webhook is working?

The simplest method is to create an alert with your webhook URL and trigger it manually by setting a condition your current chart already meets (for example, price crossing a level the market has already passed). Then check two things: TradingView's alert log to confirm the webhook was sent successfully (HTTP 200), and your bridge's dashboard or server logs to confirm the payload arrived and was parsed correctly. If you're using FillEdge, the dashboard has a one-click test button that sends a synthetic signal through the full pipeline and shows you the result at every stage.

Why did my TradingView alert fire but no trade appeared on my broker?

Four possible failure points. First, the webhook itself may have failed (check TradingView's alert log for an HTTP error or timeout). Second, the bridge received it but couldn't parse the payload (malformed message, wrong placeholder syntax, missing fields). Third, the bridge forwarded the order but the broker rejected it (market closed, insufficient margin, invalid symbol name). Fourth, the alert message is stale because you edited your Pine Script without recreating the alert. TradingView does not update existing alert messages when you change the underlying script.

Can I send one TradingView webhook alert to multiple broker accounts?

Not from TradingView directly. TradingView sends each alert to one webhook URL. To fan out to multiple accounts, you need a bridge that supports signal multiplying. FillEdge's signal multiplier does exactly this: one alert hits your webhook URL, and FillEdge routes it to as many broker accounts as you configure, each with its own lot size multiplier. Every fork is reconciled and journaled separately, so you can track how the same signal performed across all your accounts.