TradingView webhook → broker: end-to-end automation.

You designed a strategy in Pine Script and want it to trade on its own. But TradingView doesn't execute orders at your broker directly (except for native integrations). The bridge is the webhook: the alert fires, sends a message to a server of yours, and that server executes the order via the broker's API. This guide builds that entire pipeline — and is honest about where it can fail.

01The end-to-end architecture

There are four links. Understanding the flow is essential before writing a line:

02Step 1: the alert in TradingView

In your Pine Script, you use alert() with a JSON message (for the server to interpret). Then, when creating the alert in the interface, you paste your webhook URL into the "Webhook URL" field.

// in Pine Script — a structured JSON message
if ta.crossover(fast_ma, slow_ma)
    alert('{"secret":"MY_SECRET","action":"BUY","asset":"BTCUSDT","qty":0.01}',
          alert.freq_once_per_bar_close)

The secret is vital — it's what stops anyone who discovers your URL from firing fake orders. We'll see the validation on the server.

03Step 2: the receiver server

A simple Python server with FastAPI that receives the webhook, validates the secret and processes it:

# server.py
from fastapi import FastAPI, Request, HTTPException
import os

app = FastAPI()
SECRET = os.getenv("WEBHOOK_SECRET")   # never hardcode

@app.post("/webhook")
async def webhook(request: Request):
    data = await request.json()

    # 1. validate the secret — blocks fake requests
    if data.get("secret") != SECRET:
        raise HTTPException(status_code=403, detail="Unauthorized")

    # 2. interpret the signal
    action = data.get("action")
    asset  = data.get("asset")
    qty    = data.get("qty")

    # 3. execute at the broker (a function from your execution module)
    if action == "BUY":
        execute_buy(asset, qty)
    elif action == "SELL":
        execute_sell(asset, qty)

    return {"status": "ok", "action": action}

The execute_buy function uses the broker's API — exactly the code we showed in the Binance tutorial or the MT5 API. The webhook only replaces the part that "decides" — now Pine Script is what decides.

04Step 3: where to host the server

The server needs a public URL and must be always on. Options:

• VPS (the same one as the bot) — full control, a fixed IP so you can filter. See our VPS guide.
• Deploy platforms (Render, Railway, Fly.io) — spin up the server quickly, with limited free tiers. Good for testing.
• Local tunnel (ngrok) — for testing only, temporarily exposes your local PC. Never for production.

05Webhook vs. native integration

Before building this entire pipeline, consider the alternative: some brokers have a native integration with TradingView — you send the order straight from the chart, with no intermediary server. Pepperstone is an example. Compare:

• Webhook + server: flexible (works with any broker that has an API), but adds points of failure (server, latency, security) and requires maintenance.
• Native integration: simpler and more reliable (no server of yours in the middle), but limited to the brokers that offer it and to what the integration allows.

06The honest risks of webhook automation

Practices that reduce the risk: log every request received and every order sent; implement idempotency (each alert has an ID, ignore repeats); have a "kill switch" (a way to shut everything off fast); and — always — test the whole pipeline on a demo account for weeks before any real money.

07Frequently asked questions