5 Ferramentas de Análise Cripto que os Profissionais Usam

Dune Analytics

Para resolver problemas sob medida, o Dune é simplesmente indispensável, mas é uma ferramenta cheia de manhas. No fim das contas, o que você tem ali é só uma interface SQL conectada a um banco de dados gigantesco cheinho de dados on-chain brutos. Se você precisa pescar o fluxo líquido de capital nos pools da Uniswap v3 ou dar aquela espiada nos saldos reais das carteiras de insiders logo após um mint pesado — o único caminho é por lá.

A grande verdade é que, se você não manjar da sintaxe do PostgreSQL, vai ficar completamente perdido. Até dá para usar os dashboards prontos da comunidade, mas é aí que mora o perigo. Uns meses atrás, a gente topou com um dashboard super famoso sobre o volume de redes Layer 2 que estava inflando as métricas quase pelo dobro. No fim das contas, o criador tinha feito um inner join todo torto, duplicando as transações a cada nova chamada do contrato. Então, confiar cegamente no dashboard dos outros é furada; o esquema é revisar o código da query na unha.

Token Terminal

Se a sua ideia é analisar projetos Web3 com a mesma seriedade de um negócio tradicional, o Token Terminal costuma ser o porto seguro. A plataforma puxa todas as métricas financeiras clássicas: P/E ratio (múltiplo de lucro), receita total e o lucro líquido dos protocolos.

Às vezes, debruçar sobre essas tabelas dá um belo banho de realidade. O projeto pode até figurar no top 30 em termos de valor de mercado, mas aí você abre a aba de taxas acumuladas e o faturamento real não passa de uma merreca. Todo o crescimento foi sustentado na base da impressão desenfreada de tokens nativos distribuídos como recompensa de staking. Assim que a emissão cai, a economia do token desaba junto. Vale lembrar que, para analisar memecoins ou tokens recém-lançados que não têm um modelo de negócios de verdade, o serviço é 100% inútil, já que não existem dados para calcular nada.

Uma palavrinha sobre os macroindicadores da Glassnode

Quando o assunto é a análise dos ciclos de longo prazo do Bitcoin, a Glassnode é quase uma unanimidade entre os analistas. Métricas como o NUPL (Lucro/Prejuízo Líquido Não Realizado) ou o saldo de moedas guardadas nas carteiras das corretoras são ótimas para dar o contexto geral do mercado — mostrando se a galera está prestes a entrar em pânico ou se, pelo contrário, o sentimento geral já virou pura ganância extrema.

Mas ó, nem pense em usar isso como sinal de entrada ou saída imediata. Os indicadores da Glassnode são extremamente lentos. O mercado pode estar bizarramente sobrecomprado pelas métricas on-chain, e mesmo assim o preço continuar subindo por mais duas semanas no mais puro hype das liquidações forçadas. Além disso, a política de preços deles é salgada: pagar centenas de dólares por mês para ter acesso às métricas de nível T3 só faz sentido se você for um player institucional.

DefiLlama

O agregador definitivo do ecossistema DeFi. A plataforma ganhou o mercado porque faz um esforço real para limpar o TVL (Total Value Locked), eliminando a contagem dupla de capital que rola solta quando um mesmo colateral é reinvestido consecutivamente através de vários protocolos de empréstimo alavancado.

Ainda assim, nem tudo são flores. Logo após grandes atualizações de rede, o detalhamento de alguns pools de liquidez específicos pode atrasar algumas horas ou até dias. Já passamos por uma situação em que o protocolo atualizou a lógica do smart contract e o DefiLlama passou uns dois dias mostrando TVL zerado no pool, sendo que o pau estava quebrando nas negociações por lá. De qualquer forma, olhando para a cobertura de setores como RWA (Ativos do Mundo Real) ou staking líquido, quase não dá para competir com os caras.

Coinglass

Uma ferramenta de nicho indispensável para quem monitora o mercado de futuros. É o lugar certo para acompanhar o open interest (contratos em aberto), as taxas de financiamento (funding rates) e os mapas de calor de liquidação.

Na prática: de vez em quando, aqueles blocos gigantescos de stop orders acumulados no heatmap funcionam como um verdadeiro ímã para o preço. Isso não quer dizer que o mercado vai correr para lá com 100% de certeza, mas essas zonas de alta densidade sempre chamam a atenção das grandes baleias que precisam de contraparte volumosa para fechar suas posições. Só um aviso: não confie cegamente nos dados históricos do Coinglass — eles costumam reajustar os gráficos de liquidações passadas retroativamente quando as corretoras demoram para liberar os logs.

O guia rápido de métricas

Para não dar nó na cabeça tentando lembrar onde fica cada coisa, o jeito mais fácil é se guiar pelo seu objetivo principal:

• Dune: caçar pegadas de baleias e auditar a distribuição de tokens em smart contracts;
• Token Terminal: auditar o faturamento real e a relação entre valor de mercado e taxas geradas;
• Glassnode: avaliar zonas globais de capitulação e topo de mercado para BTC/ETH;
• DefiLlama: monitorar o TVL geral e acompanhar o volume de emissão de stablecoins;
• Coinglass: analisar o Funding Rate e farejar possíveis zonas de short/long squeeze nos futuros.

Automatizando a caça a anomalias via API

Ficar atualizando página o dia inteiro é perda de tempo. O lance mais inteligente é montar um script simples que consome as métricas de derivativos da API do Coinglass e acende um alerta vermelho sempre que houver uma variação bizarra no Open Interest (OI) bem na hora que o mercado começar a chacoalhar.

import logging
import os
from typing import Any, Dict, List, Optional
import requests
# Configurações de logging para produção
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
)
logger = logging.getLogger("CoinglassAnalyzer")
# Limiares para a lógica de negócio (bom deixar em um arquivo de config)
OI_CHANGE_THRESHOLD_PCT = 12.0
LIQUIDATION_THRESHOLD_USD = 40_000_000.0
class CoinglassClient:
    """Client para interagir com a API v2 do Coinglass e rodar análises básicas de mercado."""
    
    BASE_URL = "https://open-api.coinglass.com/public/v2"
    def __init__(self, api_key: Optional[str] = None):
        # Dá prioridade para a chave passada no código, se não houver, busca nas variáveis de ambiente
        self.api_key = api_key or os.getenv("COINGLASS_API_KEY")
        if not self.api_key:
            raise ValueError("Chave de API do Coinglass não encontrada. Passe no construtor ou defina a variável de ambiente COINGLASS_API_KEY")
        self.session = requests.Session()
        self.session.headers.update({
            "accept": "application/json",
            "coinglassSecret": self.api_key
        })
    def fetch_liquidation_data(self, symbol: str) -> Optional[List[Dict[str, Any]]]:
        """
        Busca os dados de liquidação de um ticker específico.
        O endpoint v2 de liquidações costuma retornar uma lista por exchange ou um array agregado.
        """
        url = f"{self.BASE_URL}/derivatives/orderbook_liquidation"
        params = {"symbol": symbol.upper()}
        try:
            response = self.session.get(url, params=params, timeout=10)
            response.raise_for_status()
            payload = response.json()
            # Valida o flag customizado de sucesso da API do Coinglass
            if str(payload.get("code")) != "0" and not payload.get("success"):
                logger.error(f"A API retornou um erro para {symbol}: {payload.get('msg', 'Erro desconhecido')}")
                return None
            # Na v2, as informações costumam vir na chave 'data', podendo ser uma lista ou dicionário
            return payload.get("data")
        except requests.RequestException as e:
            logger.error(f"Falha de rede ao buscar dados de {symbol}: {e}")
            return None
    def analyze_market(self, symbol: str) -> Optional[Dict[str, Any]]:
        """Analisa os dados de mercado com base no open interest e nas liquidações obtidas."""
        raw_data = self.fetch_liquidation_data(symbol)
        if not raw_data:
            return None
        # A API do Coinglass pode retornar uma lista de objetos por exchange.
        # Um código profissional precisa aceitar tanto um dicionário isolado quanto um array.
        main_data = raw_data[0] if isinstance(raw_data, list) and raw_data else raw_data
        if not isinstance(main_data, dict):
            logger.error(f"Formato de dados inválido retornado pela API para {symbol}")
            return None
        try:
            # Extração segura garantindo a conversão de tipos
            oi = float(main_data.get("openInterest") or 0)
            oi_change = float(main_data.get("openInterestChgVolPercentage") or 0)
            liq = float(main_data.get("totalLiquidationVolume") or 0)
        except (ValueError, TypeError) as e:
            logger.error(f"Erro ao converter os valores numéricos de {symbol}: {e}")
            return None
        alerts = []
        if abs(oi_change) >= OI_CHANGE_THRESHOLD_PCT:
            alerts.append(f"Signifcant OI Shift: {oi_change:.2f}%")
        if liq >= LIQUIDATION_THRESHOLD_USD:
            alerts.append(f"High Liquidation Volume: ${liq:,.0f}")
        # Log informativo do status atual do processo
        logger.info(
            f"{symbol.upper()} | OI: ${oi:,.0f} | Δ OI: {oi_change:.2f}% | "
            f"24h Liq: ${liq:,.0f} | Alerts Triggered: {len(alerts)}"
        )
        # Dispara os avisos caso algum gatilho tenha sido acionado
        for alert in alerts:
            logger.warning(f"ALERT [{symbol.upper()}]: {alert}")
        return {
            "symbol": symbol.upper(),
            "open_interest": oi,
            "oi_change_pct": oi_change,
            "liquidations_24h": liq,
            "alerts": alerts
        }
if __name__ == "__main__":
    # Exemplo prático de inicialização e execução do script em tempo real
    # Para testar, você pode colar sua chave direto aqui ou rodar no terminal: export COINGLASS_API_KEY="sua_chave"
    try:
        analyzer = CoinglassClient()
        analysis_result = analyzer.analyze_market("BTC")
        
        if analysis_result:
            print("\n--- Resultados da Análise ---")
            print(analysis_result)
            
    except ValueError as err:
        logger.critical(err)