Como criar uma estratégia Pine Script no TradingView sem programar – ao vivo com IA

Você precisa saber programar para criar uma estratégia no TradingView usando Pine Script? A resposta curta é: não.

Neste artigo documentamos uma sessão real ao vivo onde criamos uma estratégia Pine Script do zero, sem escrever uma linha de código manualmente.

A ferramenta usada foi o Claude Code, um assistente de IA da Anthropic que opera direto no terminal.

Este é o Art. 2 da Série Bot CriptoMatiko, que documenta a criação de um bot de trading algorítmico do zero.

Aqui você vai ver o processo completo: da ideia da estratégia ao Pine Script funcional no TradingView, incluindo backtest real e configuração de alertas.

O código gerado nesta sessão está disponível para estudo e adaptação - está claramente rotulado como exemplo educacional. Leia o aviso abaixo antes de continuar.

Preciso saber programar para criar uma estratégia Pine Script no TradingView?

Não. Com Claude Code você descreve a lógica da sua estratégia em linguagem natural e ele gera o Pine Script. O que você precisa é saber descrever claramente: quando entrar, quando sair e qual o risco por operação.

O que você vai precisar

Para replicar esta sessão você precisa de três elementos: Claude Code instalado no terminal, uma conta no TradingView e a descrição da sua estratégia em texto simples.

Claude Code instalado no seu computador

O Claude Code é o assistente de IA que vai transformar a descrição da sua estratégia em Pine Script. Se você ainda não tem o Claude Code instalado, confira o guia oficial de instalação do Claude Code antes de continuar.

Para este tutorial, usamos o Claude Code diretamente no terminal do Windows. O processo é idêntico no Mac ou Linux. Uma sessão de claude code trading como esta leva menos de 15 minutos.

TradingView - escolha seu plano

Para criar, testar e configurar alertas básicos com Pine Script, a conta gratuita é suficiente. Para conectar a estratégia a um bot via webhook - o próximo passo desta série - você vai precisar do plano Essential.

Se você ainda está avaliando os planos, veja nossa análise sobre se o TradingView vale a pena para traders de cripto.

A ideia da sua estratégia

Você não precisa de uma especificação formal. Basta saber responder três perguntas: Quando entro? Quando saio? Qual o risco por operação?

O Claude Code não inventa a estratégia por você - ele codifica exatamente o que você descreve. A qualidade do Pine Script gerado depende diretamente da clareza da sua descrição.

Como estruturar sua estratégia antes de abrir o Claude Code

O Claude Code codifica exatamente o que você descreve - a qualidade do Pine Script gerado depende diretamente da clareza da especificação. Nesta seção mostramos como documentar a sua estratégia em linguagem natural antes de abrir o terminal.

O que é Pine Script no TradingView?

Pine Script é a linguagem de programação nativa do TradingView. É usada para criar indicadores, estratégias e alertas personalizados diretamente na plataforma. Com IA, você pode gerar Pine Script sem escrever uma linha de código - basta descrever a lógica.

Descreva sua estratégia em linguagem natural

Antes de abrir o Claude Code, escreva sua estratégia em um arquivo de texto simples. Não precisa ser técnico - pode ser "entro quando o RSI sai de sobrecompra com preço fazendo nova máxima".

Quanto mais preciso você for nos casos-limite, melhor o Pine Script gerado. Este é o processo central do tradingview com pine script usando IA.

Nossa estratégia de exemplo: Divergência de RSI

A estratégia que escolhemos para esta sessão ao vivo foi a Divergência de RSI com confirmação de momentum em 4H. O conceito: quando o preço faz uma nova máxima mas o RSI não confirma, pode haver enfraquecimento do momentum.

O que é divergência de RSI no trading?

Divergência de RSI ocorre quando o preço faz uma nova máxima (ou mínima) mas o RSI não confirma esse movimento.

É um sinal de enfraquecimento do momentum - o preço pode estar prestes a reverter. O setup é composto por 4 passos sequenciais com confirmação de momentum via SMA do RSI.

O setup SHORT exige: (1) RSI acima de 70, (2) preço renova máxima com RSI saindo de sobrecompra, (3) RSI cruza abaixo da sua SMA(5), (4) sinal disparado no fechamento da vela. O setup LONG é o espelho exato. SL fixo em 1% da vela de disparo, TP em 2R (duas vezes o risco).

Configurando a sessão no Claude Code

Com a estratégia documentada, o próximo passo é preparar o ambiente no Claude Code. Dois arquivos de texto são suficientes para definir tudo o que o assistente precisa saber antes de gerar o Pine Script.

O que é Claude Code e como funciona com Pine Script?

Claude Code é um assistente de IA da Anthropic que opera no terminal do seu computador. Você descreve sua estratégia em arquivos de texto (.md), e ele gera o código Pine Script pronto para colar no TradingView.

Criando a pasta da estratégia

O primeiro passo é criar uma pasta dedicada para a sessão. Criamos a pasta C:\EstrategiaTV e abriu o Claude Code nela. Dentro desta pasta, dois arquivos de texto vão definir toda a sessão: CLAUDE.md e estrategia.md.

O arquivo CLAUDE.md - definindo o papel do assistente

O CLAUDE.md define o papel do Claude Code para esta sessão: ele vai se comportar como um especialista em Pine Script v5.

Este arquivo não muda entre estratégias - você pode reutilizar o mesmo template. Copie o conteúdo abaixo e salve como CLAUDE.md na pasta da sua estratégia:

# Contexto da Sessão — Estratégia Pine Script

Você é um especialista em Pine Script v5 e análise técnica. Nesta sessão vamos implementar uma estratégia completa no TradingView a partir da especificação em `estrategia.md`.

## Objetivo

Gerar um script Pine Script v5 funcional que implemente a estratégia de divergência de RSI descrita em `estrategia.md`, incluindo:

- Máquina de estados (4 passos sequenciais) para setup SHORT e LONG
- Sinais visuais no gráfico (setas ou triângulos no fechamento da vela)
- Gerenciamento de risco embutido: SL e TP calculados automaticamente
- Todos os parâmetros configuráveis via input.*() no topo do script

## Arquivo de saída

Salvar o código final em `pine_script.pine` nesta mesma pasta.

## Padrão de código

- Pine Script v5 (//@version=5)
- Estratégia: usar strategy() com calc_on_every_tick=false (apenas velas fechadas)
- Comentários em português
- Parâmetros agrupados no topo com group= nos inputs

## Regras de trabalho

- Implementar a lógica de estado exatamente como descrita — não simplificar sem avisar
- Se encontrar ambiguidade na especificação, perguntar antes de assumir
- Antes de gerar o código final, descrever a lógica da máquina de estados para validação

O arquivo estrategia.md - a sua estratégia por escrito

O estrategia.md é onde você descreve a lógica da sua estratégia. Este é o arquivo real que usamos nesta sessão - adapt-o para a sua própria ideia.

Quanto mais detalhado, melhor o Pine Script gerado:

# Estratégia: Divergência de RSI com Confirmação de Momentum (4H)

Estratégia baseada em divergência de RSI em 4 passos sequenciais, operando exclusivamente em velas fechadas de 4H.

## Parâmetros configuráveis

| Parâmetro     | Valor padrão | Descrição                              |
|---------------|-------------|----------------------------------------|
| rsi_length    | 14          | Período do RSI                         |
| rsi_ma_length | 5           | Período da SMA aplicada ao RSI         |
| rsi_ob        | 70          | Nível de sobrecompra                   |
| rsi_os        | 30          | Nível de sobrevenda                    |
| lookback_limit| 200         | Máximo de velas antes de resetar       |
| sl_pct        | 1.0         | Stop loss em % acima/abaixo da vela    |
| tp_mult       | 2.0         | Multiplicador de risco para TP (2R)    |

## Setup SHORT (divergência de topo)

Step 1: Vela fecha com RSI > 70. Guardar high em ref_high.
Step 2: Vela posterior faz high > ref_high E RSI <= 70. Confirma divergência.
  Exceção: se high > ref_high mas RSI ainda > 70, atualizar ref_high (renovação).
Step 3: RSI cruza abaixo da sua SMA(5). Pode ocorrer junto com step 2.
Step 4: Sinal SHORT disparado no fechamento da vela.

SL = high da vela de disparo x (1 + sl_pct/100)
TP = entrada - (SL - entrada) x tp_mult

## Setup LONG (divergência de fundo) — espelho do SHORT

Step 1: RSI < 30. Guardar low em ref_low.
Step 2: low < ref_low E RSI >= 30. Confirma divergência.
Step 3: RSI cruza acima da sua SMA(5).
Step 4: Sinal LONG disparado.

SL = low x (1 - sl_pct/100)
TP = entrada + (entrada - SL) x tp_mult

## Resets

- Lookback: resetar setup após lookback_limit velas sem confirmar sinal.
- RSI contrário: setup SHORT cancela se RSI entra em sobrevenda (e vice-versa).

A sessão ao vivo: do texto ao código Pine Script

Com os dois arquivos prontos, abrimos o Claude Code na pasta da estratégia e iniciamos a sessão. Do primeiro prompt ao Pine Script funcional, o processo levou menos de 15 minutos.

Primeiro prompt: validar a lógica antes de gerar

O processo de criar estratégia tradingview com IA começa com uma validação. Antes de pedir o Pine Script, pedimos ao Claude Code para descrever a máquina de estados em bullets - sem gerar código ainda.

Isso evita surpresas e garante que a lógica será implementada exatamente como planejado.

Confirmando os pontos e gerando o código

Após validar a lógica, confirmamos os 4 pontos levantados pelo Claude Code e pediu a geração do Pine Script. O resultado: 155 linhas de Pine Script funcional, geradas em aproximadamente 3 minutos. Este é o processo real de pine script sem programar com IA.

O código Pine Script gerado

Nota: o código abaixo foi gerado nesta sessão ao vivo como exemplo educacional. Disponibilizamos para que você possa estudar a lógica, testar no seu TradingView e adaptar à sua própria estratégia.

Este não é um sistema validado para operações reais e não deve ser interpretado como recomendação de investimento.

// =============================================================================
// Estratégia: Divergência de RSI (4H) — CriptoMatiko
// Site: criptomatiko.com
// Uso educacional — não constitui conselho financeiro ou de investimento.
// Resultados de backtest não garantem resultados futuros.
// Trading de criptomoedas envolve risco real de perda de capital.
// =============================================================================
//@version=5
strategy("Divergência de RSI 4H — CriptoMatiko", shorttitle="RSI Div | CM", overlay=true,
     calc_on_every_tick=false,
     default_qty_type=strategy.percent_of_equity, default_qty_value=100)

// =============================================================================
// PARÂMETROS
// =============================================================================
rsi_length     = input.int(14,    "Período RSI",             minval=1,             group="RSI")
rsi_ma_length  = input.int(5,     "Período SMA do RSI",      minval=1,             group="RSI")
rsi_ob         = input.float(70,  "Sobrecompra",             minval=51, maxval=99, group="RSI")
rsi_os         = input.float(30,  "Sobrevenda",              minval=1,  maxval=49, group="RSI")
lookback_limit = input.int(200,   "Lookback máximo (velas)", minval=10,            group="Setup")
sl_pct         = input.float(1.0, "Stop Loss (%)",           minval=0.01, step=0.1, group="Risco")
tp_mult        = input.float(2.0, "Multiplicador TP (R)",    minval=0.1,  step=0.1, group="Risco")

// =============================================================================
// INDICADORES
// =============================================================================
rsi     = ta.rsi(close, rsi_length)
rsi_sma = ta.sma(rsi, rsi_ma_length)

// =============================================================================
// MÁQUINA DE ESTADOS
// 0=neutro | 1=SHORT_S1 | 2=SHORT_S2 | 3=LONG_S1 | 4=LONG_S2
// =============================================================================
var int   state          = 0
var float ref_high       = na
var float ref_low        = na
var int   lookback_count = 0

signal_short = false
signal_long  = false

if state == 0
    if rsi > rsi_ob
        state          := 1
        ref_high       := high
        lookback_count := 0
    else if rsi < rsi_os
        state          := 3
        ref_low        := low
        lookback_count := 0

else if state == 1  // SHORT step 1 — aguardando Higher High
    lookback_count := lookback_count + 1
    if lookback_count > lookback_limit
        state          := 0
        ref_high       := na
        lookback_count := 0
    else if rsi < rsi_os  // RSI contrário: transferir para LONG
        state          := 3
        ref_low        := low
        ref_high       := na
        lookback_count := 0
    else if high > ref_high
        if rsi > rsi_ob  // renovação: preço renova máxima ainda sobrecomprado
            ref_high := high
        else              // divergência: HH com RSI fora da sobrecompra
            if rsi < rsi_sma  // steps 2+3+4 simultâneos
                signal_short   := true
                state          := 0
                ref_high       := na
                lookback_count := 0
            else
                state := 2

else if state == 2  // SHORT step 2 — aguardando RSI < RSI_SMA
    lookback_count := lookback_count + 1
    if lookback_count > lookback_limit
        state          := 0
        ref_high       := na
        lookback_count := 0
    else if rsi < rsi_os  // RSI contrário: transferir para LONG
        state          := 3
        ref_low        := low
        ref_high       := na
        lookback_count := 0
    else if rsi < rsi_sma  // step 3: momentum confirmado — disparo
        signal_short   := true
        state          := 0
        ref_high       := na
        lookback_count := 0

else if state == 3  // LONG step 1 — aguardando Lower Low
    lookback_count := lookback_count + 1
    if lookback_count > lookback_limit
        state          := 0
        ref_low        := na
        lookback_count := 0
    else if rsi > rsi_ob  // RSI contrário: transferir para SHORT
        state          := 1
        ref_high       := high
        ref_low        := na
        lookback_count := 0
    else if low < ref_low
        if rsi < rsi_os  // renovação: preço renova mínima ainda sobrevendido
            ref_low := low
        else              // divergência: LL com RSI fora da sobrevenda
            if rsi > rsi_sma  // steps 2+3+4 simultâneos
                signal_long    := true
                state          := 0
                ref_low        := na
                lookback_count := 0
            else
                state := 4

else if state == 4  // LONG step 2 — aguardando RSI > RSI_SMA
    lookback_count := lookback_count + 1
    if lookback_count > lookback_limit
        state          := 0
        ref_low        := na
        lookback_count := 0
    else if rsi > rsi_ob  // RSI contrário: transferir para SHORT
        state          := 1
        ref_high       := high
        ref_low        := na
        lookback_count := 0
    else if rsi > rsi_sma  // step 3: momentum confirmado — disparo
        signal_long    := true
        state          := 0
        ref_low        := na
        lookback_count := 0

// =============================================================================
// ENTRADAS E SAÍDAS DA ESTRATÉGIA
// =============================================================================
if signal_short
    sl_short = high * (1.0 + sl_pct / 100.0)
    tp_short = close - (sl_short - close) * tp_mult
    strategy.entry("SHORT", strategy.short)
    strategy.exit("SHORT_EXIT", from_entry="SHORT", stop=sl_short, limit=tp_short)
    alert("RSI Div SHORT — " + syminfo.ticker + " | Fechamento: " + str.tostring(close, "#.##") + " | " + str.format_time(time, "yyyy-MM-dd HH:mm", syminfo.timezone), alert.freq_once_per_bar_close)

if signal_long
    sl_long = low * (1.0 - sl_pct / 100.0)
    tp_long  = close + (close - sl_long) * tp_mult
    strategy.entry("LONG", strategy.long)
    strategy.exit("LONG_EXIT", from_entry="LONG", stop=sl_long, limit=tp_long)
    alert("RSI Div LONG — " + syminfo.ticker + " | Fechamento: " + str.tostring(close, "#.##") + " | " + str.format_time(time, "yyyy-MM-dd HH:mm", syminfo.timezone), alert.freq_once_per_bar_close)

// =============================================================================
// SINAIS VISUAIS
// =============================================================================
plotshape(signal_short, "Sinal SHORT", shape.triangledown, location.abovebar,
     color.new(color.red, 0), size=size.small)
plotshape(signal_long,  "Sinal LONG",  shape.triangleup,   location.belowbar,
     color.new(color.lime, 0), size=size.small)

// Usar "Any alert() function call" no TradingView ao criar o alerta

Parâmetro	Valor padrão	O que controla
rsi_length	14	Período do RSI
rsi_ma_length	5	Período da SMA aplicada ao RSI
rsi_ob	70	Nível de sobrecompra
rsi_os	30	Nível de sobrevenda
lookback_limit	200	Máximo de velas antes de resetar o setup
sl_pct	1.0%	Stop Loss em % acima/abaixo da vela de disparo
tp_mult	2.0	Multiplicador de risco para o Take Profit (padrão: 2R)

Colando o Pine Script no TradingView e configurando

Com o arquivo pine_script.pine gerado, o próximo passo é colocar o código em funcionamento no TradingView - sem instalar nada, direto no Pine Editor da plataforma.

Abrindo o Pine Editor e adicionando ao gráfico

Com o Pine Script gerado, abra o TradingView e acesse o Pine Editor no menu inferior. Cole o código, clique em "Add to chart" e aguarde a compilação.

Se não houver erros de sintaxe, os triângulos SHORT (vermelho) e LONG (verde) aparecem diretamente no gráfico.

Testamos em ETH/USDT 4H e o tradingview com pine script funcionou sem ajustes adicionais.

Configurando os parâmetros da estratégia

Clique no ícone de engrenagem ao lado do nome da estratégia no gráfico para acessar os inputs. Os 7 parâmetros configuráveis aparecem agrupados exatamente como definidos no Pine Script.

Para criar estratégia tradingview com parâmetros otimizados, você pode ajustar cada valor pelo painel de inputs sem precisar editar o código.

Resultados do backtest: ETH/USDT 4H (dez/2020 a abr/2026)

Após criar estratégia tradingview e adicionar ao gráfico, o Strategy Tester calcula os resultados históricos automaticamente. Testamos em ETH/USDT 4H com o período de dezembro de 2020 a abril de 2026.

Os números abaixo são dados históricos - resultados passados não garantem performance futura.

Métrica	Resultado
P&L total	+218,67%
Total de trades	145
Win rate	41,38%
Profit factor	1,33
Max drawdown	38,20%
Período	Dez/2020 – Abr/2026

O win rate de 41,38% pode parecer baixo, mas é esperado em um sistema 2R: cada trade vencedor ganha o dobro do que um perdedor perde.

Em outras palavras, você precisa acertar menos de metade das operações para ter resultado positivo historicamente.

O profit factor de 1,33 indica que os ganhos superaram as perdas em 33% no período testado.

O drawdown de 38,20% é um número relevante e não deve ser suavizado: em algum momento do período, a estratégia teria reduzido o capital em aproximadamente 38% antes de recuperar.

Para contexto, o ETH teve drawdowns superiores a 80% no mesmo período - mas isso não torna o drawdown da estratégia aceitável para todos os perfis de risco.

Configurando alertas no TradingView para esta estratégia Pine Script

Com a estratégia funcionando no gráfico, o próximo passo é configurar alertas para receber uma notificação cada vez que um sinal SHORT ou LONG disparar - sem precisar ficar olhando o gráfico.

Como configurar alertas para uma estratégia Pine Script no TradingView?

Em scripts strategy(), use a função alert() dentro do código Pine Script. Ao criar o alerta no TradingView, selecione "Any alert() function call" na condição.

Um único alerta cobre sinais SHORT e LONG - a mensagem identifica qual disparou, incluindo o ticker e o preço de fechamento.

Durante esta sessão ao vivo, encontramos um detalhe importante: alertcondition() não funciona em scripts strategy() no TradingView. A função existe, mas ao criar o alerta, os nomes definidos não aparecem no dropdown.

A solução é usar alert() diretamente dentro dos blocos if signal_short e if signal_long, que é como o código acima está implementado. Este tipo de detalhe prático é o que só aparece ao testar ao vivo - não na documentação.

Como testar uma estratégia no TradingView antes de operar?

Use o Strategy Tester, disponível na barra inferior do TradingView. Ele mostra métricas como win rate, profit factor, drawdown máximo e equity curve com dados históricos.

Para criar estratégia tradingview e testá-la, basta adicionar o Pine Script ao gráfico - o tester atualiza automaticamente. Resultados de backtest não garantem performance futura.

Conclusão - do zero ao Pine Script em uma sessão

O processo completo de criar uma estratégia Pine Script sem programar, do zero ao código funcional no TradingView:

• Criar a pasta da estratégia e abrir o Claude Code
• Escrever o CLAUDE.md definindo o papel do assistente
• Descrever a estratégia no estrategia.md em linguagem natural
• Validar a lógica com o Claude Code antes de gerar o código
• Colar o Pine Script no TradingView e configurar alertas

Este é o Art. 2 da Série Bot CriptoMatiko - se você está começando, leia primeiro o Art. 1: Vale a pena criar seu próprio robô trader? O código acima está disponível como ponto de partida para estudar a lógica e criar estratégia tradingview com a sua própria abordagem.

Não interprete os resultados do backtest como validação para uso real. O Pine Script gerado é um exemplo educacional - adapte, teste e avalie com responsabilidade.

Nos próximos artigos da série continuamos documentando o processo: do Pine Script ao bot automatizado, com Python e API de exchange. Acompanhe a série para ver o ciclo completo de desenvolvimento de um trading bot pine script real.

Alguns links neste artigo são de afiliados, com bônus exclusivos para você. Como isso funciona?