BLACK FRIDAY IS BACKNov 24 to 30. Join the list and get in a day early.Join the list

Does TradingView resend a webhook alert?

Autoview · Guide · Updated November 8, 2026

Sometimes, in some cases. TradingView documents an exact resubmission policy, and it's narrower than a lot of troubleshooting guides make it sound. Here's the real rule, what it means for an alert pointed at Autoview, and the two cases where a resend could still happen.

TradingView's actual policy

Per TradingView's own webhook resubmission documentation: if the server receiving the webhook responds with an HTTP status code between 500 and 599, with the single exception of 504, TradingView resends the identical webhook after 5 seconds. It will do this up to 3 times, so one alert firing can produce as many as 4 total delivery attempts if every one of them comes back with a 500-599 status.

That's the whole policy. It doesn't cover timeouts on their own, it doesn't cover 4xx responses, and it explicitly carves out 504. A lot of troubleshooting content simplifies this to "TradingView doesn't retry," which is close but not accurate, or leaves the status-code detail out entirely. The 500-599 trigger is real and worth knowing if you're trying to reason about whether a resend could ever double up an order.

The opposite problem has its own rule: TradingView stops an alert that triggers more than 15 times in 3 minutes, and a stopped alert sends nothing at all. Why isn't my alert reaching Autoview? covers it.

When an alert arrives late

Autoview acts on an alert when it receives it. It doesn't check how old the alert is, and there's no setting that drops a late one. An alert that reaches Autoview a minute after it fired is handled the same way as one that arrived at once.

A resend is a late copy by design. Under the policy above, each resend goes out 5 seconds after the attempt before it, so the third and last one reaches Autoview at least 15 seconds after the first. Autoview handles it when it arrives, like any other alert.

To see how late an alert was, compare two times: when TradingView fired it, from your TradingView alert log, and when Autoview received it, from the time on its entry in your Autoview log. Put both times in the same time zone first. TradingView says its alerts log shows your computer's time zone, but its CSV export is in UTC (What timezone is displayed in alerts?). Autoview's log shows your browser's local time, with no zone label. If you use the extension's Export Log file instead, it stores each entry's time as a Unix timestamp in milliseconds. If your alert message carries its own time, use {{timenow}}, not {{time}}. TradingView documents {{timenow}} as the moment the alert fired, to the second, in UTC. {{time}} comes from the bar the alert triggered on, so on a higher timeframe it can sit well before the fire time even when nothing was delayed.

dt= is not a freshness check either. It sets how long a resting order waits on the exchange before it expires. A late alert with dt= still places its order. Autoview passes dt= to five exchanges: Capital.com, Charles Schwab, Coinbase Advanced, OANDA and TradeStation. On Capital.com and Coinbase Advanced it applies only to limit-type orders, not market orders. Gate.io trigger orders use et= instead, a number of seconds. The order expiry guide lists what each of the five does with it.

The expiry format differs by exchange, so check the reference for yours: OANDA, Capital.com and Gate.io (for et=). For Charles Schwab, Coinbase Advanced and TradeStation there is no Autoview reference page yet, so use the exchange's own API documentation for its order expiry field.

A late alert's order is priced when Autoview receives it, not when the alert fired. On most exchanges Autoview supports, Binance, OKX, Kraken and OANDA among them, a p= offset is measured from the exchange's price at that moment. If the market moved while the alert was on its way, the order moves with it. To stop a late alert chasing the market, send a limit order with fp={{close}}. Autoview uses an fp= price as is, so the limit stays at the chart price from when the alert fired. Add dt= on the five exchanges above if the order should also expire. On OANDA, fpb= sets a fixed price bound on the order. None of this drops a late alert: the order is still placed, and a resting limit may never fill. The Pine strategy placeholders guide uses fp= the same way, with the price TradingView's strategy filled at.

What Autoview actually sends back

Every response Autoview's webhook endpoint returns under normal operation falls into two buckets, and neither one is in TradingView's resend range:

  • 200, when the request is accepted. Autoview returns this immediately on receipt, before it has placed any order on a connected exchange, so its own processing time never factors into whether TradingView considers the delivery slow.
  • A 4xx rejection, when something about the request itself is wrong: 415 for an unsupported content type, 400 for a JSON body that is neither a JSON string nor an object with a string "alert" field, 404 for an unknown hook, 401 for a bad webhook key, 411 for an empty request body, or 422 when no exchange account is linked to the hook. Every one of these is a client-side rejection code, none of them 500 or above.

A normal rejection, of any kind Autoview's webhook logic produces on purpose, sits outside the 500-599 window. TradingView won't resend it, and Autoview won't see the same alert twice because of this mechanism.

When a resend can still happen

This isn't a claim that a resend is impossible, just that it isn't caused by anything Autoview's own webhook logic does on purpose. If something fails before Autoview's code gets far enough to send one of the responses above, for example a backend outage severe enough that the database read behind hook validation fails outright, the hosting platform can return a generic server error in the 500-599 range on Autoview's behalf. That status would fall inside TradingView's resend window, and a resubmission could follow.

That's an infrastructure failure, not a routine rejection or a slow trade. It isn't something you can trigger by sending a malformed alert message, hitting a rate limit, or having a trade take a while to fill. If you ever suspect this happened, the log is the place to check: two identical entries seconds apart, both otherwise looking normal, would be the signature.

A mistyped webhook URL

There is one more 500, and this one you can cause. If the hook ID in your webhook URL is mistyped or cut short when you paste it, Autoview answers with a 500 instead of a 404. We checked this on October 28, 2026: a URL with an ID in the wrong format got HTTP 500 with the body error code: 1101, while a correctly shaped ID that doesn't exist got 404. TradingView treats that 500 like any other server error and resends the alert up to 3 times.

That can't place an order. Each attempt fails at the same step, before Autoview reads the alert or looks for a linked account, so nothing reaches an exchange. If your alerts show 500 errors or error 1101, copy the webhook URL from Autoview again and paste it into the alert.

If you're worried about the order itself, not just the alert

A resent webhook and a duplicate order are two different questions. This page is about whether TradingView sends the same alert twice. For what actually causes Autoview to place two orders from what looks like one signal, including the far more common causes (two senders both pointed at the same account, or a repainting indicator firing twice honestly), see duplicate or repeated orders. Its dedupe= parameter doesn't run on the cloud webhook platform, so it wouldn't catch a resend-driven repeat either, but that mechanism is not the one this page is about.

See duplicate order causes