Crie um bot de trading de cripto com IA: do testnet à VPS

Criar um bot de trading de cripto com IA é realmente fácil hoje: um agente de código como Claude Code ou Codex consegue escrever um bot em Python que se conecta a uma exchange via ccxt, roda uma estratégia simples e envia ordens. O trabalho de verdade é tudo em volta do código: testar no testnet e em backtests, limitar a chave de API a operar e passar para dinheiro real com valores mínimos.

Este guia vai passo a passo de uma pasta vazia até um bot que roda 24/7 num servidor e manda alertas pelo Telegram. Antes, porém, a parte em que preciso ser direto.

Risco primeiro: isto não é recomendação financeira

Este é um tutorial de software, não uma recomendação de investimento. Alguns fatos logo de cara:

• A maioria dos bots de trading perde dinheiro. Principalmente as estratégias simples que você encontra por aí, quando se contam taxas, slippage e movimentos bruscos.
• Uma estratégia que parece ótima no backtest muitas vezes falha ao vivo. Estratégias ajustadas aos dados do passado (overfitting) desmoronam rápido.
• Código escrito por IA pode conter bugs caros. Uma unidade de quantidade errada, uma condição de compra/venda invertida ou um loop de retry que continua enviando ordens pode zerar uma conta em minutos.
• Só dê a um bot o dinheiro que você pode perder. Comece no testnet e depois vá para o real com o menor valor que a exchange permite.

A estratégia deste post é um exemplo de código. Não estou apresentando-a como uma forma de ganhar dinheiro.

Qual stack escolher

Quando você faz vibe coding de um bot, escolha a stack que o agente conhece melhor. Minha escolha:

• Python 3.11+: o ecossistema mais maduro para dados (pandas), backtesting e bibliotecas de exchange, e a linguagem em que os agentes viram mais exemplos.
• ccxt: uma biblioteca open source que fala com muitas exchanges por uma única interface. Código escrito para uma exchange normalmente passa para outra mudando poucas linhas, e ela suporta o modo testnet/sandbox de muitas exchanges.
• pandas: para trabalhar com dados de candles (OHLCV) como tabela.
• python-dotenv: para manter as chaves de API num arquivo .env, fora do código.
• SQLite: para registrar posições abertas e ordens sem rodar um servidor de banco de dados.

Configuração:

mkdir crypto-bot && cd crypto-bot
git init
python3 -m venv .venv && source .venv/bin/activate
pip install ccxt pandas python-dotenv requests
echo ".env" >> .gitignore
echo ".venv/" >> .gitignore

Adicione essas linhas ao .gitignore no primeiro minuto. Uma chave de API enviada ao GitHub sem querer é o erro mais comum e mais caro de toda esta área.

Passo 1: uma conta de testnet e uma chave de API com o escopo certo

Muitas exchanges grandes oferecem um ambiente de teste (testnet ou sandbox) onde nenhum dinheiro real se move. Procure “testnet” ou “sandbox” na documentação para desenvolvedores da exchange e crie lá uma conta de teste e uma chave de API de teste separadas. Se não houver testnet, ou se o seu par não estiver nele, vamos pedir ao agente um modo de paper trading que lê preços reais, mas só registra as ordens localmente.

Quando você finalmente criar uma chave na conta real:

• Ative só leitura e trade. Nunca ative saques. Se a chave vazar, ninguém consegue mandar seus fundos para outro lugar.
• Use whitelist de IP. Se a exchange permitir, trave a chave no IP fixo da sua VPS.
• Mantenha futuros e margem desativados. Comece pelo spot.
• Crie uma chave por bot, para poder revogar só aquela se algo der errado.

Um arquivo .env fica assim:

EXCHANGE=binance
API_KEY=your-test-key
API_SECRET=your-test-secret
USE_TESTNET=true
TELEGRAM_TOKEN=
TELEGRAM_CHAT_ID=

Não cole esses valores no chat com o agente. O agente precisa saber que o .env existe, não o que tem dentro dele.

Passo 2: o primeiro prompt

Abra o agente na pasta do projeto (claude ou codex) e peça o bot em camadas, não tudo de uma vez. Um primeiro prompt que você pode copiar:

Set up a skeleton for a simple spot trading bot in Python 3.11 with ccxt.
Rules:
- Read settings from .env with python-dotenv. Never open or print .env.
- If USE_TESTNET=true, enable ccxt sandbox mode; otherwise print a
  "LIVE MODE" warning on start and wait 10 seconds.
- Modules: config.py, exchange.py (connection, balance, candles, orders),
  strategy.py (returns a signal, never places orders), risk.py (position
  size, daily loss limit), bot.py (main loop), storage.py (SQLite log).
- Every order must pass risk.py first. Max 2% of balance per order;
  stop the bot if the daily loss exceeds 5%.
- With DRY_RUN=true, never place orders, only log them.
- Use Python logging to logs/bot.log and the console.
- No strategy yet: strategy.py should always return "hold".
When done, summarize the file layout and how to run it.

Por que um esqueleto primeiro? Manter estratégia, envio de ordens e regras de risco em arquivos separados deixa o código mais fácil de revisar e os bugs mais fáceis de pegar. Se a estratégia não consegue enviar ordens, um bug nela produz no máximo um sinal errado, e a camada de risco limita o estrago.

Passo 3: uma estratégia de exemplo (cruzamento de médias móveis)

De novo: isto é um exemplo, não uma recomendação. O cruzamento de médias móveis é uma das estratégias mais claras para mostrar a estrutura. Quando a média rápida cruza acima da lenta, ela sinaliza “comprar”; quando cruza abaixo, “vender”.

# strategy.py — example only, not financial advice
import pandas as pd

def signal(ohlcv: list, fast: int = 20, slow: int = 50) -> str:
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    if len(df) < slow + 2:
        return "hold"
    df["fast"] = df["close"].rolling(fast).mean()
    df["slow"] = df["close"].rolling(slow).mean()
    prev, last = df.iloc[-3], df.iloc[-2]  # the last candle is still open, skip it
    if prev.fast <= prev.slow and last.fast > last.slow:
        return "buy"
    if prev.fast >= prev.slow and last.fast < last.slow:
        return "sell"
    return "hold"

Um detalhe que vale notar: o sinal é calculado a partir do último candle fechado, porque o mais recente ainda está se movendo. Agentes costumam esquecer isso, e o bot acaba entrando e saindo dentro de um mesmo candle.

Prompt para adicioná-la:

Add a 20/50 moving average crossover to strategy.py. Compute signals from
closed candles only. Write pytest tests for the signal function: cross up,
cross down, not enough data and a flat market. Run the tests and show me
the output.

Passo 4: backtesting

Antes de ir ao vivo, rode a estratégia com dados históricos. Você pode pedir ao agente para buscar candles com ccxt e escrever um loop de backtest simples. Para algo mais sério, veja backtesting.py, vectorbt ou Freqtrade; o Freqtrade é um framework de bots open source maduro que já inclui backtesting, dry-run e controle pelo Telegram.

Um prompt:

Write backtest.py. Fetch the last year of BTC/USDT 1h candles with ccxt,
paginating, and save them as CSV under data/. Apply strategy.signal candle
by candle without looking ahead. Deduct 0.1% fee and 0.05% slippage per
trade. Report total return, number of trades, win rate, max drawdown and
buy-and-hold return over the same period.

Ao ler os resultados:

• Sempre inclua taxas e slippage. Sem elas quase qualquer estratégia parece boa.
• Compare com o buy-and-hold. Se o bot se sai pior do que simplesmente segurar, não vale o esforço.
• Procure você mesmo o look-ahead bias. Leia o loop e confira que ele nunca usa dados que ainda não existiam.
• Não ajuste parâmetros até a curva ficar bonita. Se 17/43 ganha de 20/50, o mais provável é que seja acaso.

Passo 5: testnet e paper trading

Depois do backtest, rode o bot no testnet por pelo menos alguns dias:

DRY_RUN=false USE_TESTNET=true python bot.py

Nesta etapa você está verificando comportamento, não lucro. As ordens saem com a quantidade certa? O bot lembra de uma posição aberta depois de reiniciar? Quando a exchange retorna um erro, ele quebra ou espera e tenta de novo? O limite de perda diária realmente entra em ação?

Provoque uma falha de propósito, por exemplo uma ordem maior que o seu saldo, e veja o bot registrar isso de forma limpa e parar.

Passo 6: rate limits, tratamento de erros e logs

As exchanges limitam as requisições de API. Um bot que passa do limite primeiro recebe erros e, se continuar, pode ser bloqueado temporariamente. A opção enableRateLimit do ccxt espaça as requisições automaticamente; peça ao agente para confirmar que ela está ligada.

Review exchange.py:
- Make sure ccxt enableRateLimit is on.
- On NetworkError and RateLimitExceeded, retry up to 5 times with
  increasing backoff. On InsufficientFunds and InvalidOrder, do not retry;
  log it and send a Telegram alert.
- Log the request, exchange response and order id for every order.
- Prevent a second order for the same signal (idempotency).

Uma boa linha de log responde depois à pergunta “por que o bot fez isso?”: horário, sinal, preço, quantidade calculada, resultado da checagem de risco, id da ordem. Nunca registre chaves de API ou segredos no log.

Passo 7: alertas no Telegram

O bot deve contar o que está fazendo. O jeito mais simples é uma chamada HTTP comum à Telegram Bot API:

# notify.py
import os, requests

def send(text: str) -> None:
    token, chat = os.getenv("TELEGRAM_TOKEN"), os.getenv("TELEGRAM_CHAT_ID")
    if not token or not chat:
        return
    try:
        requests.post(f"https://api.telegram.org/bot{token}/sendMessage",
                      json={"chat_id": chat, "text": text}, timeout=10)
    except requests.RequestException:
        pass  # a failed alert must not stop the bot

Você obtém o token pelo fluxo oficial de criação de bots do Telegram. Eventos que merecem alerta: bot iniciado/parado, ordem enviada, erro, limite de perda diária atingido. Meu guia sobre como criar um bot de Telegram com IA mostra como adicionar comandos, por exemplo para parar o bot remotamente.

Passo 8: rodando 24/7 numa VPS

Quando seu notebook dorme, o bot dorme junto. Uma VPS Linux pequena basta; um IP fixo importa para a whitelist de IP.

Com systemd

# /etc/systemd/system/crypto-bot.service
[Unit]
Description=Crypto bot
After=network-online.target

[Service]
User=bot
WorkingDirectory=/home/bot/crypto-bot
EnvironmentFile=/home/bot/crypto-bot/.env
ExecStart=/home/bot/crypto-bot/.venv/bin/python bot.py
Restart=on-failure
RestartSec=30

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now crypto-bot
journalctl -u crypto-bot -f

Rode o bot com um usuário próprio, não como root, e proteja o arquivo de ambiente com chmod 600 .env.

Com Docker

Se você prefere Docker, peça ao agente um Dockerfile e um docker-compose.yml com restart: unless-stopped, env_file para o .env e volumes para logs/ e o arquivo SQLite, para que o bot e seus registros sobrevivam a um reboot do servidor.

Erros comuns: o que a IA costuma errar

• Quantidades e precisão. As exchanges impõem quantidade mínima e precisão decimal por par. Agentes pulam isso e recebem ordens rejeitadas, ou arredondam para o lado errado. Peça para usar o amount_to_precision do ccxt e os limites do mercado.
• Usar o candle aberto. Sinais de um candle que ainda está se movendo são ruído.
• Flag de testnet ligada em produção, ou desligada nos testes. Registre o modo bem visível ao iniciar.
• Perder o estado ao reiniciar. Se o bot esquece uma posição aberta, pode comprar de novo. Persista o estado no SQLite e reconcilie com a exchange ao iniciar.
• Ordens dentro de um loop de retry. Se a lógica de retry envolve o envio da ordem, a mesma ordem pode sair várias vezes.
• Erros engolidos. except: pass em todo lugar faz um bot que parece vivo e não faz nada.
• Confiar no “os testes passaram”. Olhe a saída você mesmo.

Checklist de segurança

• As chaves de API ficam só no .env, e o .env está no .gitignore.
• Nunca cole chaves no agente, num chat ou numa screenshot.
• Saques desativados, whitelist de IP ativada, margem desativada.
• Leia os comandos que o agente quer rodar antes de aprovar, especialmente qualquer coisa que leia o .env, envie arquivos ou faça chamadas de rede.
• Se suspeitar que uma chave vazou, revogue-a na exchange na hora e crie uma nova.
• Ative a autenticação de dois fatores na conta da exchange.
• Instale dependências que você conhece; confira qualquer nome de pacote sugerido pelo agente que você nunca ouviu falar.

Fazendo isso com o AgentVera

Em projetos assim eu rodo mais de um agente lado a lado. Numa grade do AgentVera você pode ter o Claude Code trabalhando na estratégia e no backtest numa worktree enquanto o Codex monta os alertas do Telegram e os arquivos Docker em outra, sem um mexer nos arquivos do outro. Depois de cada turno, o code review automático faz um segundo modelo ler o que o agente escreveu, um segundo par de olhos útil para a matemática das quantidades e as condições de compra/venda. Você revisa o diff no painel de Git antes do merge e vê o uso de tokens por agente. Quando o bot está pronto, o SSH e SFTP leva os arquivos para a VPS, e o gerenciador de Docker mostra o contêiner localmente.

Nada disso é obrigatório; dois terminais e git também funcionam. Se a configuração em paralelo te interessa, veja agentes de código em paralelo.

Conclusão

A parte de código de criar um bot de trading de cripto com IA leva algumas horas: Python, ccxt, módulos bem separados, uma camada de risco e bons logs. O que leva tempo e realmente importa é testar: backtest, testnet, paper trading e só então um valor ao vivo mínimo. Restrinja a chave de API a trade, desative os saques e leia cada linha de ordem que o agente escrever. E lembre que a maioria dos bots perde dinheiro; crie este para aprender, não para ficar rico.