5 herramientas de análisis cripto que usan los profesionales

Dune Analytics

Para consultas personalizadas, Dune es una locura, pero es una herramienta con bastante personalidad. Básicamente, estás frente a una interfaz SQL conectada a una base de datos gigante de datos on-chain puros y duros. Si necesitás trackear el flujo neto de capital que entra a los pools de Uniswap v3 o revisar los saldos reales de las billeteras de los insiders después de un mint masivo, tu único camino es por acá.

Eso sí, si no dominás la sintaxis de PostgreSQL, estás frito. Obvio que podés usar los dashboards ya armados por la comunidad, pero ahí es donde está la trampa. Hace un par de meses nos topamos con un dashboard súper popular que medía el volumen de las redes de Layer 2 y estaba inflando las métricas casi al doble. Resulta que el creador armó mal un inner join y duplicaba las transacciones cada vez que se volvía a llamar al contrato. Así que confiar a ciegas en dashboards ajenos es una pésima idea; siempre hay que revisar el código de las queries a mano.

Token Terminal

Si querés analizar proyectos de Web3 como si fueran empresas tradicionales, el lugar cantado es Token Terminal. La plataforma te tira las métricas financieras de siempre: el P/E ratio, los ingresos y las ganancias netas de los protocolos.

A veces, ponerse a mirar estas tablas te baja a la realidad de un hondazo. Capaz que un proyecto está cómodo en el top 30 de capitalización de mercado, pero abrís la pestaña de comisiones y lo que genera de ingresos reales son monedas. Todo ese crecimiento ficticio se sostenía porque el equipo se la pasaba emitiendo sus propios tokens nativos para repartirlos como recompensas de staking. En cuanto baja la emisión, la economía del proyecto se desmorona. Por supuesto, si querés analizar memecoins o tokens recién salidos del horno que no tienen un modelo de negocio, este servicio no te sirve para nada porque directamente no hay datos para calcular nada.

Un par de palabras sobre los macroindicadores de Glassnode

Para analizar los ciclos de Bitcoin a largo plazo, la mayoría de los analistas recurren a Glassnode. Métricas como el NUPL (ganancia/pérdida neta no realizada) o los balances de monedas en los exchanges te dan un panorama excelente del contexto general del mercado: te avisan si se está gestando una capitulación por pánico o si, por el contrario, estamos todos metidos en una codicia extrema (Extreme Greed).

Pero tomarlos como señales de trading directas es un error garantizado. Los indicadores de Glassnode se mueven a paso de tortuga. El mercado puede estar recontra recalentado según las métricas on-chain, y aun así el precio puede seguir subiendo un par de semanas más impulsado puramente por el FOMO de las liquidaciones. Además, los precios de sus suscripciones duelen bastante: pagar cientos de dólares al mes para acceder a métricas de nivel T3 solo tiene sentido si sos un jugador institucional.

DefiLlama

Es el agregador definitivo para todo lo que es el ecosistema DeFi. Lo mejor que tiene es que intenta limpiar las métricas del TVL (Total Value Locked) para evitar el doble conteo de capital, algo clave cuando un mismo colateral se vuelve a reinvertir a través de varios protocolos de préstamos con apalancamiento.

Aunque bueno, acá también hay pifias. Cuando hay actualizaciones grandes en las redes, el desglose de ciertos pools de liquidez puede quedar desactualizado por varias horas o incluso días. Nos pasó ver un protocolo que cambió la lógica de su smart contract y DefiLlama estuvo un par de días mostrando el TVL de ese pool en cero, cuando el volumen de trading ahí adentro estaba prendido fuego. De todos modos, para trackear sectores como RWA (activos del mundo real) o liquid staking, hoy casi no tienen competencia.

Coinglass

Esta es una herramienta muy específica para seguir de cerca el mercado de futuros. Acá venís a buscar el Open Interest (interés abierto), las tasas de financiación (Funding Rates) y los mapas de calor de las liquidaciones.

En la práctica: a veces las zonas con mucha densidad de stop loss en el mapa de calor funcionan como un imán para el precio. Esto no significa que el mercado vaya a ir ahí el 100% de las veces, pero esos niveles cargados siempre llaman la atención de las ballenas que buscan liquidez para cerrar sus posiciones grandes. Eso sí, no te fíes a ciegas de los datos históricos de Coinglass: cada tanto suelen corregir los gráficos de liquidaciones pasadas si los exchanges les mandan los logs con delay.

Un machete rápido de métricas

Para no marearte con qué buscar en cada lado, lo ideal es guiarte según lo que necesites resolver en el momento:

• Dune: cazar ballenas y grandes jugadores, y auditar la distribución de tokens de un smart contract.
• Token Terminal: auditar ingresos reales y revisar la relación entre capitalización de mercado y comisiones generadas.
• Glassnode: identificar zonas globales de capitulación y sobrecompra extrema en BTC/ETH.
• DefiLlama: monitorear el TVL y seguir el ritmo de emisión de las stablecoins.
• Coinglass: analizar el Funding Rate y detectar zonas calientes para posibles squeezes en futuros.

Automatizando la detección de anomalías vía API

Estar quemándote los ojos 24/7 mirando pantallas no tiene sentido. Es mucho más eficiente armar un script básico que haga un barrido de las métricas de derivados de Coinglass y te salte con una alerta cuando el Open Interest se vuelva loco y el mercado se empiece a picar.

import logging
import os
from typing import Any, Dict, List, Optional
import requests
# Configuración del logging para producción
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
)
logger = logging.getLogger("CoinglassAnalyzer")
# Umbrales para la lógica de negocio (ideal para mandar a un config)
OI_CHANGE_THRESHOLD_PCT = 12.0
LIQUIDATION_THRESHOLD_USD = 40_000_000.0
class CoinglassClient:
    """Cliente para interactuar con la API v2 de Coinglass y armar análisis de mercado básicos."""
    
    BASE_URL = "https://open-api.coinglass.com/public/v2"
    def __init__(self, api_key: Optional[str] = None):
        # Prioridad al key que pasamos por parámetro; si no, lo busca en las variables de entorno
        self.api_key = api_key or os.getenv("COINGLASS_API_KEY")
        if not self.api_key:
            raise ValueError("No se encontró la API key de Coinglass. Pasala al constructor o definí la variable de entorno 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]]]:
        """
        Trae los datos de liquidación para un ticker específico.
        El endpoint v2 de liquidaciones suele devolver una lista por exchange o un array consolidado.
        """
        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()
            # Validación del flag de éxito propio de la API de Coinglass
            if str(payload.get("code")) != "0" and not payload.get("success"):
                logger.error(f"La API tiró un error para {symbol}: {payload.get('msg', 'Error desconocido')}")
                return None
            # En la v2, la data clave suele venir dentro de 'data', ya sea como lista o dict
            return payload.get("data")
        except requests.RequestException as e:
            logger.error(f"Error de red al consultar la data de {symbol}: {e}")
            return None
    def analyze_market(self, symbol: str) -> Optional[Dict[str, Any]]:
        """Analiza la data de mercado cruzando liquidaciones y Open Interest."""
        raw_data = self.fetch_liquidation_data(symbol)
        if not raw_data:
            return None
        # La API de Coinglass puede devolver una lista de objetos discriminados por exchange.
        # Un código pro tiene que poder bancarse tanto un objeto único como un 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 datos inválido desde la API para {symbol}")
            return None
        try:
            # Extracción segura de datos casteando los tipos correspondientes
            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"Error al parsear los valores numéricos para {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 del proceso en curso
        logger.info(
            f"{symbol.upper()} | OI: ${oi:,.0f} | Δ OI: {oi_change:.2f}% | "
            f"24h Liq: ${liq:,.0f} | Alerts Triggered: {len(alerts)}"
        )
        # Disparamos los warnings si saltó algún trigger
        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__":
    # Ejemplo para inicializar y correr el script en vivo
    # Para probarlo rápido, meté tu key acá o exportala en la terminal: export COINGLASS_API_KEY="tu_key"
    try:
        analyzer = CoinglassClient()
        analysis_result = analyzer.analyze_market("BTC")
        
        if analysis_result:
            print("\n--- Resultados del Análisis ---")
            print(analysis_result)
            
    except ValueError as err:
        logger.critical(err)