Automação no TradingView: Pine Script v6, indicadores e webhooks

O TradingView é a plataforma de análise gráfica mais popular do mundo, com mais de 150.000 scripts da comunidade. A linguagem Pine Script v6 permite criar indicadores personalizados, estratégias com backtesting e sinais automatizados via webhooks.

Pine Script v6

Pine Script é a linguagem proprietária do TradingView, executada nos servidores da plataforma. A versão 6 (atual) trouxe melhorias significativas em performance, formatação e gerenciamento de estratégias.

Características principais

• Sintaxe leve, similar a JavaScript/C
• Todo script começa com //@version=6
• Dois tipos de script: indicator() (visual) e strategy() (backtestável)
• Funções nativas para análise técnica: ta.sma(), ta.ema(), ta.rsi(), ta.macd(), ta.crossover()
• Execução server-side (não roda localmente)
• Pine Profiler para análise de performance do código
• Métodos definidos pelo usuário via keyword method

Variáveis nativas

Tipos de dados

• int — inteiros
• float — decimais
• bool — verdadeiro/falso
• string — texto
• color — cores
• array — arrays dinâmicos
• matrix — matrizes

Criando indicadores

Passo a passo

1. Abra qualquer gráfico no TradingView
2. Clique na aba Pine Editor na parte inferior
3. Selecione Create new > Indicator
4. Escreva o código
5. Clique em Save e depois Add to Chart

Exemplo: média móvel simples

//@version=6
indicator("Minha SMA", overlay=true)

periodo = input.int(20, "Período")
sma_valor = ta.sma(close, periodo)

plot(sma_valor, "SMA", color=color.blue, linewidth=2)

Exemplo: RSI com níveis de sobrecompra/sobrevenda

//@version=6
indicator("RSI Customizado", overlay=false)

length = input.int(14, "Período RSI")
overbought = input.int(70, "Sobrecompra")
oversold = input.int(30, "Sobrevenda")

rsi_value = ta.rsi(close, length)

plot(rsi_value, "RSI", color=color.blue)
hline(overbought, "Sobrecompra", color=color.red)
hline(oversold, "Sobrevenda", color=color.green)

bgcolor(rsi_value > overbought ? color.new(color.red, 90) :
        rsi_value < oversold ? color.new(color.green, 90) : na)

Funções de plotagem

• plot() — linha no gráfico
• plotshape() — ícones/formas (setas, triângulos)
• plotchar() — caracteres
• bgcolor() — cor de fundo condicional
• barcolor() — cor dos candles
• hline() — linhas horizontais fixas
• fill() — preenche área entre duas plotagens

Criando estratégias

Estratégias simulam trades em dados históricos e em tempo real, gerando relatórios de backtesting.

Estrutura básica

//@version=6
strategy("Cruzamento de Médias", overlay=true, initial_capital=10000)

// Parâmetros
fast_length = input.int(10, "MA Rápida")
slow_length = input.int(21, "MA Lenta")

// Cálculos
fast_ma = ta.sma(close, fast_length)
slow_ma = ta.sma(close, slow_length)

// Condições
long_entry = ta.crossover(fast_ma, slow_ma)
short_entry = ta.crossunder(fast_ma, slow_ma)

// Execução
if long_entry
    strategy.entry("Long", strategy.long)

if short_entry
    strategy.entry("Short", strategy.short)

// Plotagem
plot(fast_ma, "MA Rápida", color=color.green)
plot(slow_ma, "MA Lenta", color=color.red)

Funções de ordem

• strategy.entry() — abre posição (long ou short)
• strategy.exit() — fecha com stop-loss, take-profit ou trailing stop
• strategy.close() — fecha posição por ID
• strategy.cancel() — cancela ordens pendentes

Estratégia com gestão de risco (ATR)

//@version=6
strategy("ATR Stop/Target", overlay=true, process_orders_on_close=true)

atrLen = input.int(14, title="Período ATR")
atrMult = input.float(1.5, title="Multiplicador ATR")
atr = ta.atr(atrLen)

longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))

if (longCondition)
    stop = close - atr * atrMult
    target = close + atr * atrMult
    strategy.entry("Long", strategy.long)
    strategy.exit("Exit Long", from_entry="Long", stop=stop, limit=target)

Position sizing dinâmico

//@version=6
strategy("Risk-Based Sizing", overlay=true, initial_capital=100000)

risk_pct = input.float(1.0, "Risco por trade (%)")
atr_period = input.int(14, "Período ATR")

atr = ta.atr(atr_period)
risk_amount = strategy.equity * (risk_pct / 100)
position_size = risk_amount / (atr * 2)

if ta.crossover(ta.sma(close, 10), ta.sma(close, 30))
    strategy.entry("Long", strategy.long, qty=position_size)
    strategy.exit("Exit", from_entry="Long",
                  stop=close - atr * 2,
                  limit=close + atr * 3)

Backtesting

Ao adicionar uma strategy() ao gráfico, o TradingView roda automaticamente contra dados históricos.

Strategy Tester — abas

Configurações importantes

strategy("Nome",
    overlay=true,
    initial_capital=10000,         // Capital inicial
    commission_type=strategy.commission.percent,
    commission_value=0.1,          // 0.1% por trade
    slippage=2,                    // 2 ticks de slippage
    process_orders_on_close=true,  // Executa no fechamento do candle
    default_qty_type=strategy.percent_of_equity,
    default_qty_value=10           // 10% do equity por trade
)

Alertas

Alertas notificam quando condições específicas ocorrem, sem precisar monitorar o gráfico.

Tipos de entrega

• Popup na plataforma
• Email
• Notificação no app
• Webhook (planos pagos)

Configurando alertas no Pine Script

// Alerta genérico
alert("Sinal de compra detectado!", alert.freq_once_per_bar)

// Condição nomeada (aparece no diálogo de alertas)
alertcondition(ta.crossover(ta.sma(close, 10), ta.sma(close, 20)),
    title="SMA Cross Up",
    message="SMA 10 cruzou acima da SMA 20")

Limites de alertas por plano

Webhooks — execução automatizada

Webhooks são a ponte entre sinais do TradingView e sistemas de execução externos. Requerem plano Essential ou superior.

Como funciona

1. TradingView envia HTTP POST para uma URL quando o alerta dispara
2. O corpo contém a mensagem do alerta (tipicamente JSON)
3. Seu servidor/serviço recebe e executa a ordem via API da corretora

Configuração

1. Crie um alerta no gráfico/indicador/estratégia
2. Marque Webhook URL
3. Cole a URL do endpoint (HTTPS obrigatório)
4. Formate a mensagem como JSON

Exemplo de payload

{
  "symbol": "{{ticker}}",
  "action": "{{strategy.order.action}}",
  "price": "{{close}}",
  "quantity": "{{strategy.order.contracts}}",
  "timestamp": "{{timenow}}"
}

Placeholders dinâmicos

• {{ticker}} — nome do símbolo
• {{close}}, {{open}}, {{high}}, {{low}} — preços
• {{volume}} — volume
• {{strategy.order.action}} — "buy" ou "sell"
• {{strategy.order.contracts}} — quantidade
• {{timenow}} — timestamp atual

Serviços de recebimento de webhooks

Integração com corretoras

Integrações nativas

O TradingView suporta integração direta com 50+ corretoras:

Bridges de terceiros (para corretoras sem integração nativa)

• PineConnector — TradingView → MetaTrader 4/5
• MetaConnector — TradingView → MT5
• TradersPost — conecta múltiplas corretoras

Scripts da comunidade

O TradingView hospeda mais de 150.000 scripts comunitários, metade open-source.

Tipos de script

• Open-source: código visível, pode ser estudado e forkado
• Protected: código oculto, pode ser usado mas não visualizado
• Invite-only: acesso restrito (scripts premium/pagos)

Libraries (bibliotecas)

Funções reutilizáveis publicadas como open-source, importáveis via:

import autor/NomeBiblioteca/versão as lib

Publicando scripts

1. No Pine Editor, selecione Publish Script
2. Escolha visibilidade: open-source, protected ou invite-only
3. Adicione descrição, screenshots e categorização

Limitações do TradingView

Quando TradingView é a escolha certa

• Prototipação rápida e desenvolvimento visual
• Backtesting simples sem infraestrutura
• Geração de sinais para execução externa
• Aprendizado e exploração de estratégias

Quando considerar alternativas

• Trading de alta frequência (sub-segundo)
• Estratégias multi-ativo complexas
• Integração de dados customizados
• Controle total sobre infraestrutura de execução

Guia passo a passo para iniciantes

Fase 1: Setup

1. Crie uma conta gratuita em tradingview.com
2. Abra qualquer gráfico (ex: PETR4, BTCUSD)
3. Localize o Pine Editor na parte inferior

Fase 2: Primeiro script

1. Clique em "Create new" > "Indicator"
2. Comece com //@version=6 e indicator("Meu Indicador", overlay=true)
3. Plote uma média móvel: plot(ta.sma(close, 20))
4. Salve e adicione ao gráfico

Fase 3: Conceitos essenciais

• Séries: valores que mudam a cada candle (close, volume, indicadores)
• Modelo de execução: Pine Script roda 1x por candle, do mais antigo ao mais recente
• Inputs: input.int(), input.float(), input.bool() para parametrização
• Condicionais: if/else, operador ternário condição ? valor1 : valor2

Fase 4: Progressão prática

1. Plote uma SMA no gráfico
2. Plote duas SMAs com cores diferentes
3. Adicione sinais de compra/venda com plotshape()
4. Converta para strategy() com strategy.entry()
5. Adicione stop-loss e take-profit com strategy.exit()
6. Parametrize com input() para ajustar sem editar código

Estratégias mais populares

Cruzamento de médias móveis

Buy quando MA rápida cruza acima da lenta, sell no inverso. Simples e eficaz para mercados com tendência.

RSI Mean Reversion

Compra quando RSI < 30, vende quando > 70. Melhor para mercados laterais.

MACD Momentum

Cruza a linha MACD acima do sinal para comprar. Captura tendências direcionais.

Bollinger Bands Breakout

Compra quando preço rompe a banda superior, vende na inferior. Forte em mercados voláteis.

ATR Risk Management

Stop-loss e take-profit dinâmicos baseados em ATR. Adapta-se à volatilidade atual.

Fontes de aprendizado

Documentação oficial

• Pine Script v6 User Manual
• Pine Script v6 Language Reference
• Migration Guide to v6
• Release Notes

Cursos gratuitos

• Pine Script Basics Course — Zen & The Art of Trading
• Pine Script Lessons & Tutorials
• TradingCode Pine Script Course

Cursos pagos

• Pine Script Mastery Course (223 lições)
• Udemy — Pine Script Courses

Outros recursos

• AlgoTrading101 — Pine Script Guide
• TradingView Community Scripts
• Pineify — gerador de código via IA
• Pine Script v6 for LLMs (GitHub)

Precisa de desenvolvimento profissional?

Se você precisa de indicadores Pine Script customizados, estratégias automatizadas via webhooks ou integração com corretoras, a RedBlock é especialista em engenharia de software para o mercado financeiro — do sinal à execução automatizada.

Fale com a RedBlock

Aviso Legal: Conteúdo educativo. Não constitui recomendação de investimento. Resultados passados em backtesting não garantem resultados futuros.