5 narzędzi analizy krypto, których używają profesjonaliści

Dune Analytics

Do niestandardowych zadań Dune jest po prostu niezastąpiony, ale to narzędzie z charakterem. W gruncie rzeczy dostajemy surowy interfejs SQL podpięty do gigantycznej bazy surowych danych on-chain. Jeśli chcesz wyciągnąć przepływy kapitału netto do pul Uniswap v3 albo sprawdzić realne salda portfeli insiderów zaraz po grubym mincie – nie ma innego adresu.

Haczyk polega na tym, że bez znajomości składni PostgreSQL nie masz tam czego szukać. Jasne, można korzystać z gotowych dashboardów od społeczności, ale to pułapka. Parę miesięcy temu trafiliśmy na popularny dashboard mierzący wolumen na sieciach Layer 2, który niemal dwukrotnie zawyżał metryki. Okazało się, że twórca skopał inner joina i transakcje się dublowały przy wielokrotnych wywołaniach kontraktu. Także ślepe ufanie cudzym dashboardom to słaby pomysł – logikę zapytań zawsze trzeba weryfikować ręcznie.

Token Terminal

Jeśli chcesz prześwietlić projekty Web3 niczym klasyczny biznes, zazwyczaj odpalasz Token Terminal. Platforma agreguje tradycyjne wskaźniki finansowe, takie jak wskaźnik P/E, przychody czy marżę zysku netto protokołów.

Czasami analiza tych tabel działa jak zimny prysznic. Projekt może wisieć w top 30 pod względem kapitalizacji, a wchodzisz w zakładkę opłat protokołu i widzisz groszowe realne przychody. Cały ten wzrost opierał się na tym, że team bezczelnie drukował natywne tokeny i rozdawał je w ramach nagród za staking. W momencie gdy emisja spada, cała tokenomia leci na łeb. Z drugiej strony, przy analizie memcoinów czy świeżych tokenów bez żadnego modelu biznesowego ten serwis jest kompletnie bezużyteczny – po prostu brakuje danych do jakichkolwiek wyliczeń.

Parę słów o wskaźnikach makro od Glassnode

Przy analizie długoterminowych cykli Bitcoina wielu analityków opiera się na Glassnode. Metryki takie jak NUPL (niezrealizowany zysk/strata netto) czy przepływy na giełdach całkiem nieźle pokazują ogólny sentyment rynkowy – czy wjeżdża już panika, czy wręcz przeciwnie, wszyscy toną w ekstremalnej chciwości.

Ale traktowanie ich jako gotowych sygnałów do wejścia w pozycję to spory błąd. Wskaźniki Glassnode bywają potwornie opóźnione. Rynek może wyglądać na kosmicznie przegrzany w ujęciu on-chain, a cena potrafi rosnąć przez kolejne dwa tygodnie napędzana czystym short squeezem i likwidacyjnym hypem. Do tego dochodzi cennik, który potrafi ugryźć w portfel: płacenie setek dolarów miesięcznie za dostęp do metryk poziomu T3 ma sens właściwie tylko w przypadku funduszy instytucjonalnych.

DefiLlama

Niekwestionowany król agregatorów sektora DeFi. Platforma kupuje użytkowników tym, że stara się czyścić wskaźnik TVL (Total Value Locked) z podwójnego liczenia kapitału, kiedy ten sam zastaw jest wielokrotnie reinkasowany przez różne protokoły pożyczkowe z dźwignią.

Mimo to wpadki zdarajają się i tutaj. Po dużych aktualizacjach sieci szczegółowe dane dla poszczególnych pul płynności potrafią łapać opóźnienia rzędu kilku godzin, a nawet dni. Mieliśmy sytuację, gdzie protokół zmienił logikę smart kontraktu, a DefiLlama przez dwa dni pokazywała okrągłe zero TVL dla puli, mimo że handel szedł tam pełną parą. Niemniej jednak, pod kątem pokrycia takich sektorów jak RWA (aktywa ze świata rzeczywistego) czy płynny staking, ciężko o lepszą alternatywę.

Coinglass

Wysoce wyspecjalizowane narzędzie stworzone stricte do monitorowania rynku kontraktów futures. Tutaj zagląda się po to, by śledzić Open Interest (otwarte pozycje), stawki fundingowe oraz mapy likwidacji.

Z doświadczenia: duże skupiska zleceń stop na mapie cieplnej potrafią działać na cenę jak magnes. Nie oznacza to, że rynek na 100% tam pójdzie, ale strefy o tak dużym zagęszczeniu płynności zawsze przyciągają uwagę animatorów rynku i wielkich graczy, którzy szukają głębokiego arkusza do zrealizowania swoich sporych pozycji. Warto jednak pamiętać, że nie można ślepo wierzyć historycznym danym na Coinglass – zdarza im się modyfikować wykresy minionych likwidacji, jeśli giełdy przesyłają logi z opóźnieniem.

Szybka ściągawka z metryk

Żeby się nie pogubić w tym, gdzie czego szukać, najlepiej podzielić to sobie według konkretnych potrzeb:

• Dune: tropienie ruchów wielorybów i audyt dystrybucji tokenów w smart kontraktach;
• Token Terminal: weryfikacja realnych przychodów projektu i badanie stosunku kapitalizacji do generowanych opłat;
• Glassnode: wyznaczanie makro stref kapitulacji oraz przegrzania cykli na BTC/ETH;
• DefiLlama: śledzenie zmian w TVL oraz monitorowanie wolumenu emisji stablecoinów;
• Coinglass: analiza wskaźników Funding Rate i wypatrywanie potencjalnych short/long squeeze'ów na kontraktach terminowych.

Automatyzacja wykrywania anomalii przez API

Siedzenie godzinami i gapienie się w dashboardy mija się z celem. O wiele prościej jest skrobać krótki skrypt, który sam pociągnie metryki z API Coinglass i podświetli nagłe skoki Open Interest, gdy na rynku zaczyna się gruba jazda.

import logging
import os
from typing import Any, Dict, List, Optional
import requests
# Ustawienia logowania dla środowiska produkcyjnego
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
)
logger = logging.getLogger("CoinglassAnalyzer")
# Wartości progowe dla logiki biznesowej (wygodne do wydzielenia w pliku konfiguracyjnym)
OI_CHANGE_THRESHOLD_PCT = 12.0
LIQUIDATION_THRESHOLD_USD = 40_000_000.0
class CoinglassClient:
    """Klient do obsługi API Coinglass v2 i podstawowej analizy rynku."""
    
    BASE_URL = "https://open-api.coinglass.com/public/v2"
    def __init__(self, api_key: Optional[str] = None):
        # Priorytet dla przekazanego klucza, w przeciwnym razie pobieramy ze środowiska
        self.api_key = api_key or os.getenv("COINGLASS_API_KEY")
        if not self.api_key:
            raise ValueError("Klucz API Coinglass nie został znaleziony. Przekaż go do konstruktora lub ustaw zmienną środowiskową 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]]]:
        """
        Pobiera dane dotyczące likwidacji dla konkretnego symbolu.
        Endpoint v2 dla likwidacji zazwyczaj zwraca listę według giełd lub zagregowaną tablicę.
        """
        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()
            # Weryfikacja niestandardowej flagi powodzenia Coinglass API
            if str(payload.get("code")) != "0" and not payload.get("success"):
                logger.error(f"API zwróciło błąd dla {symbol}: {payload.get('msg', 'Nieznany błąd')}")
                return None
            # W wersji v2 dane zazwyczaj znajdują się w 'data' i może to być zarówno lista, jak i słownik
            return payload.get("data")
        except requests.RequestException as e:
            logger.error(f"Błąd sieciowy podczas zapytania o dane dla {symbol}: {e}")
            return None
    def analyze_market(self, symbol: str) -> Optional[Dict[str, Any]]:
        """Analizuje dane rynkowe na podstawie pobranych likwidacji oraz Open Interest (OI)."""
        raw_data = self.fetch_liquidation_data(symbol)
        if not raw_data:
            return None
        # API Coinglass może zwracać listę obiektów pogrupowanych według giełd.
        # Kod produkcyjny musi prawidłowo obsługiwać zarówno pojedynczy obiekt, jak i tablicę.
        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"Nieprawidłowy format danych z API dla {symbol}")
            return None
        try:
            # Bezpieczne wyciąganie danych wraz z rzutowaniem typów
            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"Błąd parsowania wartości liczbowych dla {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}")
        # Informacyjny log z przebiegu procesu
        logger.info(
            f"{symbol.upper()} | OI: ${oi:,.0f} | Δ OI: {oi_change:.2f}% | "
            f"24h Liq: ${liq:,.0f} | Alerts Triggered: {len(alerts)}"
        )
        # Wyświetlanie ostrzeżeń, jeśli aktywowały się triggery
        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__":
    # Przykład inicjalizacji i uruchomienia skryptu "na żywo"
    # Do testów możesz wkleić swój klucz bezpośrednio tutaj lub wyeksportować go w terminalu: export COINGLASS_API_KEY="twój_klucz"
    try:
        analyzer = CoinglassClient()
        analysis_result = analyzer.analyze_market("BTC")
        
        if analysis_result:
            print("\n--- Wyniki analizy ---")
            print(analysis_result)
            
    except ValueError as err:
        logger.critical(err)