⬡ API · AUTOMAÇÃO · LEITURA 13 MIN

Webhook do TradingView → corretora: automação ponta a ponta.

Como transformar um alerta de Pine Script numa ordem real na corretora. A arquitetura completa, o código do servidor receptor, e os riscos honestos dessa abordagem.

Por Equipe RoboTraderIA· atualizado mai/2026· nível avançado

Você desenhou uma estratégia em Pine Script e quer que ela opere sozinha. Mas o TradingView não executa ordens na sua corretora diretamente (salvo integrações nativas). A ponte é o webhook: o alerta dispara, manda uma mensagem pra um servidor seu, e esse servidor executa a ordem via API da corretora. Este guia monta esse pipeline inteiro — e é honesto sobre onde ele pode falhar.

01A arquitetura ponta a ponta

São quatro elos. Entender o fluxo é essencial antes de escrever uma linha:

TradingView alerta Pine HTTP POST Seu servidor Flask/FastAPI valida API corretora ordem Mercado execução
O alerta do TradingView vira HTTP POST → seu servidor valida → chama a API da corretora → ordem executada.

Pré-requisito: o recurso de webhook em alertas exige plano pago do TradingView. Os planos gratuitos não enviam webhook. E você precisa de um servidor com URL pública (uma VPS, ou serviços tipo Render/Railway) pra receber o POST.

02Passo 1: o alerta no TradingView

No seu Pine Script, você usa alert() com uma mensagem em JSON (pra o servidor interpretar). Depois, ao criar o alerta na interface, você cola a URL do seu webhook no campo "URL do Webhook".

// no Pine Script — mensagem estruturada em JSON
if ta.crossover(ma_rapida, ma_lenta)
    alert('{"segredo":"MEU_SEGREDO","acao":"COMPRA","ativo":"BTCUSDT","qtd":0.01}',
          alert.freq_once_per_bar_close)

O segredo é vital — é o que impede que qualquer um que descubra sua URL dispare ordens falsas. Veremos a validação no servidor.

03Passo 2: o servidor receptor

Um servidor simples em Python com FastAPI que recebe o webhook, valida o segredo e processa:

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

app = FastAPI()
SEGREDO = os.getenv("WEBHOOK_SECRET")   # nunca hardcode

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

    # 1. valida o segredo — barra requisições falsas
    if dados.get("segredo") != SEGREDO:
        raise HTTPException(status_code=403, detail="Não autorizado")

    # 2. interpreta o sinal
    acao  = dados.get("acao")
    ativo = dados.get("ativo")
    qtd   = dados.get("qtd")

    # 3. executa na corretora (função do seu módulo de execução)
    if acao == "COMPRA":
        executar_compra(ativo, qtd)
    elif acao == "VENDA":
        executar_venda(ativo, qtd)

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

A função executar_compra usa a API da corretora — exatamente o código que mostramos no tutorial da Binance ou na API do MT5. O webhook só substitui a parte que "decide" — agora quem decide é o Pine Script.

Segurança é obrigatória, não opcional: sua URL de webhook é pública. Sem validação de segredo, qualquer um que descubra a URL pode disparar ordens na sua conta. Use sempre: (1) um segredo na mensagem, (2) HTTPS, (3) idealmente valide também o IP de origem do TradingView. Trate isso como você trataria a senha do banco.

04Passo 3: onde hospedar o servidor

O servidor precisa de URL pública e estar sempre no ar. Opções:

  • VPS (a mesma do robô) — controle total, IP fixo pra você poder filtrar. Veja nosso guia de VPS.
  • Plataformas de deploy (Render, Railway, Fly.io) — sobem o servidor rápido, têm plano gratuito limitado. Bom pra testar.
  • Túnel local (ngrok) — só pra testes, expõe seu PC local temporariamente. Nunca pra produção.

Precisa de uma VPS pra hospedar?

Veja como escolher e configurar a VPS que vai rodar seu servidor de webhook 24/7.

Ver guia de VPS →

05Webhook vs. integração nativa

Antes de montar todo esse pipeline, considere a alternativa: algumas corretoras têm integração nativa com o TradingView — você manda ordem direto do gráfico, sem servidor intermediário. A Pepperstone é um exemplo. Compare:

  • Webhook + servidor: flexível (funciona com qualquer corretora que tenha API), mas adiciona pontos de falha (servidor, latência, segurança) e exige manutenção.
  • Integração nativa: mais simples e confiável (sem servidor seu no meio), mas limitada às corretoras que oferecem e ao que a integração permite.

Recomendação: se sua corretora tem integração nativa e ela atende sua estratégia, prefira-a — menos coisa pra quebrar. O webhook brilha quando você precisa de lógica customizada no meio (ex: gestão de risco própria, múltiplas corretoras) ou quando a corretora só oferece API, não integração TradingView.

06Os riscos honestos da automação por webhook

O que pode dar errado (e vai, uma hora): o servidor pode cair e você perde o sinal. A requisição pode se perder na rede. Há latência entre o alerta e a execução (segundos podem importar). Um alerta pode disparar duas vezes (ordem duplicada). Você precisa de logs, idempotência (não executar a mesma ordem duas vezes) e monitoramento. Automação por webhook é poderosa, mas não é "configure e esqueça".

Práticas que reduzem o risco: logar toda requisição recebida e toda ordem enviada; implementar idempotência (cada alerta tem um ID, ignore repetidos); ter um "kill switch" (forma de desligar tudo rápido); e — sempre — testar o pipeline inteiro em conta demo por semanas antes de qualquer real.

07Perguntas frequentes

O que é um webhook do TradingView?

É uma requisição HTTP que o TradingView envia automaticamente pra uma URL sua quando um alerta dispara. Essa requisição pode acionar um servidor que executa ordens na corretora, automatizando estratégias feitas em Pine Script.

Preciso de plano pago do TradingView?

Sim. O recurso de webhook em alertas exige plano pago. Os gratuitos não permitem enviar webhook. Além disso, você precisa de um servidor com URL pública pra receber.

É seguro automatizar via webhook?

Tem riscos: a URL é pública (precisa de validação por segredo), o servidor pode cair, há latência, e alertas podem duplicar. Pra estratégias sensíveis a tempo, integração nativa é mais confiável. Sempre teste em demo e use logs, idempotência e kill switch.

Qual a diferença pra integração nativa?

Integração nativa (ex: Pepperstone) executa direto do gráfico, sem servidor seu — mais simples e confiável. Webhook é mais flexível (qualquer corretora com API, lógica customizada no meio) mas adiciona pontos de falha. Prefira nativa quando ela atender.

Posso usar webhook pra B3?

Sim, desde que sua corretora tenha API acessível. O servidor receptor chamaria a API da corretora (ou a ponte MT5-Python) pra executar na B3. O fluxo é o mesmo; muda só a função de execução no final.