Cómo crear un dashboard de análisis para Hyperliquid: de cero a uso práctico

6 may 2026

Para traders activos de Hyperliquid o investigadores cuantitativos, tener un dashboard personal que se actualice en tiempo real puede mejorar mucho la eficiencia al tomar decisiones. En esta guía verás cómo construir un panel para Hyperliquid desde la recolección y procesamiento de datos hasta la visualización en frontend, cubriendo monitoreo de posiciones, seguimiento de funding rates y análisis de PnL. Todo con herramientas open source y sin costos adicionales obligatorios.

Qué módulos debería incluir el dashboard

Un dashboard útil para Hyperliquid normalmente debería incluir estos módulos principales:

Resumen de cuenta: valor de cuenta, margen disponible, uso de margen y apalancamiento.
Monitoreo de posiciones: símbolo, dirección long/short, tamaño, precio de entrada, PnL no realizado y exposición.
Funding rates: historial por activo, comparación entre mercados y alertas por niveles anómalos.
Datos de mercado: precios, volumen, open interest, libro de órdenes o últimas operaciones.
Historial y rendimiento: evolución de equity, PnL realizado/no realizado y métricas por estrategia.
Alertas: cambios fuertes en funding, liquidación cercana, exceso de exposición o fallas de conexión.

La documentación oficial de Hyperliquid lista todos los tipos disponibles de Info Endpoint.

Elección del stack técnico

Un stack open source recomendado sería:

Recolección de datos backend: Python + requests, o aiohttp si quieres hacerlo de forma asíncrona.
Almacenamiento: SQLite para algo local y liviano, o PostgreSQL + TimescaleDB si necesitas optimización para datos de series temporales.
Framework de dashboard: Grafana, potente y compatible con fuentes SQLite/Postgres; o Streamlit, nativo de Python y muy útil para prototipos rápidos.
Datos en tiempo real: Hyperliquid WebSocket API.

Para validar rápido una idea, Streamlit suele ser la mejor opción. Para monitoreo más cercano a producción, Grafana + TimescaleDB es una configuración más robusta.

Implementación de la capa de recolección de datos

Recolección del estado de cuenta

import requests
import time

ENDPOINT = "https://api.hyperliquid.xyz/info"

def fetch_account_state(address: str) -> dict:
    payload = {"type": "clearinghouseState", "user": address}
    r = requests.post(ENDPOINT, json=payload, timeout=10)
    r.raise_for_status()
    return r.json()

def fetch_market_data() -> dict:
    payload = {"type": "metaAndAssetCtxs"}
    r = requests.post(ENDPOINT, json=payload, timeout=10)
    r.raise_for_status()
    return r.json()

Recolección masiva de funding rates

def fetch_all_funding_rates(coins: list, days: int = 1) -> dict:
    end_ms = int(time.time() * 1000)
    start_ms = end_ms - days * 24 * 3600 * 1000
    results = {}

    for coin in coins:
        payload = {
            "type": "fundingHistory",
            "coin": coin,
            "startTime": start_ms,
        }
        r = requests.post(ENDPOINT, json=payload, timeout=10)
        if r.ok:
            results[coin] = r.json()

    return results

Suscripción en tiempo real vía WebSocket

Si necesitas mostrar el libro de órdenes o las operaciones más recientes en tiempo real, puedes usar la interfaz WebSocket de Hyperliquid:

import asyncio
import websockets
import json

WS_URL = "wss://api.hyperliquid.xyz/ws"

async def subscribe_trades(coin: str):
    async with websockets.connect(WS_URL) as ws:
        sub_msg = {
            "method": "subscribe",
            "subscription": {"type": "trades", "coin": coin}
        }
        await ws.send(json.dumps(sub_msg))

        while True:
            msg = await ws.recv()
            data = json.loads(msg)
            print(data)

asyncio.run(subscribe_trades("BTC"))

Los tipos de suscripción WebSocket están detallados en la sección WebSocket de la documentación oficial de Hyperliquid.

Construir la interfaz del dashboard con Streamlit

import streamlit as st
import pandas as pd
import plotly.express as px

st.set_page_config(page_title="Hyperliquid Dashboard", layout="wide")

ADDRESS = st.sidebar.text_input("Ingresa la dirección de wallet", value="0x...")

if ADDRESS.startswith("0x"):
    state = fetch_account_state(ADDRESS)
    margin = state.get("marginSummary", {})

    col1, col2, col3 = st.columns(3)

    col1.metric("Valor de cuenta (USDC)", f"${float(margin.get('accountValue', 0)):,.2f}")
    col2.metric("Margen disponible", f"${float(margin.get('withdrawable', 0)):,.2f}")
    col3.metric(
        "Apalancamiento",
        f"{float(margin.get('totalRawUsd', 0)) / max(float(margin.get('accountValue', 1)), 1):.1f}x"
    )

    positions = state.get("assetPositions", [])

    if positions:
        pos_data = []

        for p in positions:
            pos = p.get("position", {})
            pos_data.append({
                "Activo": pos.get("coin"),
                "Dirección": "Long" if float(pos.get("szi", 0)) > 0 else "Short",
                "Tamaño de posición": abs(float(pos.get("szi", 0))),
                "PnL no realizado": float(pos.get("unrealizedPnl", 0)),
                "Precio de entrada": float(pos.get("entryPx", 0)),
            })

        df = pd.DataFrame(pos_data)
        st.dataframe(df)

        fig = px.bar(
            df,
            x="Activo",
            y="PnL no realizado",
            color="Dirección",
            title="PnL no realizado por posición"
        )
        st.plotly_chart(fig, use_container_width=True)

Construir un dashboard de producción con Grafana

Si necesitas colaboración entre varias personas, datos históricos y alertas, Grafana es una mejor opción:

Inicia Grafana localmente: docker run -d -p 3000:3000 grafana/grafana.
Configura PostgreSQL + TimescaleDB como fuente de datos.
Escribe un script programado en Python para guardar datos en la base de datos cada minuto.
Crea paneles en Grafana usando consultas SQL para construir gráficos.
Configura reglas de alerta, por ejemplo, enviar una notificación cuando el funding rate supere cierto umbral.

La documentación oficial de Grafana ofrece una guía completa para configurar paneles.

OneKey Wallet: la base de seguridad detrás del dashboard

La dirección de wallet que ingresas en el dashboard se usa para consultas de solo lectura. Sin embargo, cuando quieras ejecutar operaciones con base en las señales o métricas que estás monitoreando, la seguridad de tus llaves privadas se vuelve crítica.

OneKey Hardware Wallet almacena tus llaves privadas en un chip físico seguro. Incluso si tu computadora está comprometida por malware, las llaves privadas no pueden extraerse directamente del dispositivo.

Combinado con OneKey Perps, puedes detectar una señal en tu dashboard y luego ejecutar operaciones de perpetuos en Hyperliquid con firma por hardware. Así construyes un flujo más completo: análisis de datos + ejecución segura.

Si operas derivados y quieres separar mejor el análisis de la custodia de llaves, puedes descargar OneKey y probar OneKey Perps como parte de tu flujo de trading, siempre evaluando los riesgos antes de operar.

Preguntas frecuentes

Q1: ¿Hyperliquid ofrece un plugin oficial de fuente de datos para Grafana?

No. Actualmente no hay un plugin oficial de Grafana para Hyperliquid. Aun así, puedes consultar la API de Hyperliquid usando una fuente de datos JSON API o el plugin Infinity de Grafana, o bien guardar los datos primero en una base intermedia.

Q2: ¿La conexión WebSocket puede desconectarse automáticamente?

Sí. Una conexión WebSocket puede expirar después de mucho tiempo sin actividad. Es recomendable implementar un mecanismo de heartbeat, como ping/pong, y una lógica de reconexión automática para mantener la continuidad de la recolección de datos.

Q3: ¿El dashboard puede mostrar datos de cuentas de otras personas?

Sí. Los datos de cuenta en Hyperliquid son públicos. Solo necesitas una dirección válida de Ethereum para consultarlos. Esto también significa que tus propios datos pueden ser visibles para otras personas.

Q4: ¿Cómo puedo configurar alertas por funding rate anormal?

Puedes agregar condiciones en tu script de recolección de datos. Por ejemplo, si el funding rate supera un umbral definido, como 0.1% por hora, puedes enviar una alerta mediante Telegram Bot API o correo electrónico. Grafana también incluye funciones nativas de alertas.

Q5: ¿Streamlit o Grafana es mejor para principiantes?

Streamlit suele ser más fácil para desarrolladores Python que quieren crear un prototipo rápido; con pocas líneas de código ya puedes visualizar datos. Grafana es más adecuado para entornos de producción, colaboración y monitoreo de largo plazo. Tiene una curva de aprendizaje algo mayor, pero ofrece más capacidades.

Riesgos

Este artículo es un tutorial técnico y no constituye asesoría financiera, legal ni de inversión. El mercado de criptoactivos es altamente volátil. Los datos del dashboard son solo una referencia y no predicen rendimientos futuros. Toma decisiones de trading únicamente después de entender bien los riesgos.