On-Chain-Analyse mit Claude Code — Wallet-Tracking und Whale-Watching für Entwickler

Worum es geht

Jede Ethereum-Transaktion ist öffentlich. Wer was an wen geschickt hat, wann, mit welchem Gas. Das Gleiche für Solana, Base, Polygon, fast alle relevanten Chains. Das sind Tera-Bytes an Daten die niemand gelesen hat.

Das Problem ist nicht die Verfügbarkeit. Das Problem ist die Zugänglichkeit. Ein klassisches Dashboard-Tool wie Dune oder Nansen zeigt dir sauber aufbereitete Charts — aber wenn du was Spezifisches suchst, stehst du oft im Regen.

Claude Code ist hier überraschend stark. Nicht als Trading-Signal-Generator (das funktioniert kaum), sondern als Analyse-Copilot der aus rohen Transaktionsdaten Sinn macht. Dieser Artikel zeigt drei konkrete Pipelines die ich im Einsatz habe.

Ausgangsdaten — womit du arbeitest

Für Ethereum und L2s wie Base:

• Etherscan API v2 — Standard-Schnittstelle, kostenloses Tier mit 5 Calls/Sekunde reicht für meisten Analysen
• Alchemy — bessere Performance bei hohem Volumen, free tier mit 300M compute units/month
• DuneSQL — SQL-Interface über indexierte On-Chain-Daten, free-Tier mit begrenzten Query-Credits

Für Solana: Helius oder Quicknode. Für andere Chains jeweils die passende Explorer-API.

Pipeline 1 — Wallet-Activity-Tracker

Use-Case: Du willst eine bestimmte Wallet beobachten — z.B. eine bekannte Whale-Adresse oder die Treasury-Adresse einer DAO.

Python-Script, von Claude Code generiert:

import requests
import json
from datetime import datetime
from dataclasses import dataclass

ETHERSCAN_API = "https://api.etherscan.io/api"
WALLET = "0x..."  # Ziel-Adresse
API_KEY = "..."

def get_transactions(address, start_block=0):
    params = {
        "module": "account",
        "action": "txlist",
        "address": address,
        "startblock": start_block,
        "endblock": 99999999,
        "sort": "desc",
        "apikey": API_KEY,
    }
    r = requests.get(ETHERSCAN_API, params=params)
    return r.json()["result"]

def analyze(transactions):
    outgoing = [t for t in transactions if t["from"].lower() == WALLET.lower()]
    incoming = [t for t in transactions if t["to"].lower() == WALLET.lower()]
    total_out_eth = sum(int(t["value"]) / 1e18 for t in outgoing)
    total_in_eth = sum(int(t["value"]) / 1e18 for t in incoming)
    unique_counterparts = set(t["to"] for t in outgoing) | set(t["from"] for t in incoming)
    return {
        "total_transactions": len(transactions),
        "outgoing_eth": total_out_eth,
        "incoming_eth": total_in_eth,
        "net_flow": total_in_eth - total_out_eth,
        "unique_counterparts": len(unique_counterparts),
    }

Das ist das Skelett. Claude Code erweitert das auf Wunsch um Token-Transfers (ERC-20), Zeitstempel-Analyse (wann ist die Wallet am aktivsten?), und Muster-Erkennung (DEX-Trades vs. direkte Transfers).

Pipeline 2 — Whale-Bewegungs-Alert

Use-Case: Du willst wissen wenn eine der Top-100-Ethereum-Wallets was Außergewöhnliches macht.

Kombination aus zwei Datenquellen:

1. Etherscan für die Top-100-Holder-Liste einer Token-Contract-Adresse
2. Alchemy Webhook für Real-Time-Notifications

# Claude Code Template — vereinfacht
import websockets
import asyncio

WATCHED_WALLETS = [...]  # Top 100 holder
THRESHOLD_USD = 100_000  # Alert bei Trades > 100k

async def subscribe_wallet(wallet):
    uri = f"wss://eth-mainnet.ws.alchemy.com/v2/{API_KEY}"
    async with websockets.connect(uri) as ws:
        subscribe_msg = {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "eth_subscribe",
            "params": ["alchemy_filteredNewHeads", {"from": wallet}],
        }
        await ws.send(json.dumps(subscribe_msg))
        async for message in ws:
            data = json.loads(message)
            await handle_event(data, wallet)

async def handle_event(data, wallet):
    # Filter: value > threshold, send Telegram notification
    ...

async def main():
    await asyncio.gather(*[subscribe_wallet(w) for w in WATCHED_WALLETS])

Das Setup schickt mir eine Telegram-Nachricht wenn eine der gewatcheten Wallets was Großes macht. Nicht als Trading-Signal — sondern als Informations-Vorsprung. Zu sehen was Whales tun hilft, Marktbewegungen später besser zu interpretieren.

Pipeline 3 — DEX-Wash-Trading-Detektor

Use-Case: Du willst für eine neue Token-Contract-Adresse abschätzen ob das Volumen echt ist oder künstlich hochgepumpt.

Wash-Trading ist ein bekanntes Muster: Dieselben Wallets handeln den Token untereinander hin und her, um Volumen vorzutäuschen. Das zieht echte Käufer an, die glauben der Token sei "in Bewegung."

Detektion-Heuristiken die Claude Code implementiert:

• Repeated Wallet Pairs: Wenn zwei Wallets signifikant häufig miteinander handeln, ist das verdächtig
• Circular Flow: Token geht A → B → C → A zurück (identifiziert über DEX-Trade-Logs)
• Time Patterns: Wash-Trading läuft oft in regelmäßigen Intervallen, echter Trade ist zufällig
• Gas-Pattern: Wash-Trades werden oft mit auffallend konstanten Gas-Parametern gemacht

# Pseudocode — komplettes Script ist länger
def detect_wash_trading(token_address, time_window_days=30):
    trades = get_dex_trades(token_address, time_window_days)
    wallet_pair_freq = defaultdict(int)
    for trade in trades:
        pair = frozenset({trade.from_wallet, trade.to_wallet})
        wallet_pair_freq[pair] += 1
    
    # Suspect: Pairs with >10 trades
    suspects = {p: count for p, count in wallet_pair_freq.items() if count > 10}
    
    # Circular flow detection
    circular = find_cycles(trades, max_length=3)
    
    return {
        "wash_score": calculate_score(suspects, circular, trades),
        "suspect_pairs": suspects,
        "circular_flows": circular,
    }

Der Wash-Score ist ein 0-100-Index. Werte über 60 sind verdächtig, über 80 ist es fast sicher Wash-Trading.

Ich habe das Script an 20 zufällig ausgewählten neuen Meme-Coins der letzten 30 Tage laufen lassen. Ergebnis: 11 von 20 hatten Wash-Scores über 60. Das ist keine Randerscheinung — das ist der Default-Zustand des Meme-Coin-Markts.

DuneSQL für große Abfragen

Wenn es um historische Daten oder komplexe Aggregationen geht, sind Python-Scripts über API-Calls zu langsam. DuneSQL indexiert On-Chain-Daten und erlaubt SQL-artige Queries:

-- DuneSQL Beispiel: Top 10 Empfänger einer spezifischen Wallet in 30 Tagen
SELECT 
  "to" AS counterparty,
  COUNT(*) AS num_transactions,
  SUM(value / 1e18) AS total_eth
FROM ethereum.transactions
WHERE "from" = 0xabc...
  AND block_time > NOW() - INTERVAL '30' DAY
GROUP BY "to"
ORDER BY total_eth DESC
LIMIT 10

Claude Code schreibt diese SQL-Queries auf deine Beschreibung hin in Sekunden. Der Workflow den ich nutze:

1. Ich sag Claude: "Ich will die 20 aktivsten Solana-Wallets der letzten 7 Tage die mit Jupiter DEX interagiert haben."
2. Claude generiert DuneSQL
3. Ich führe die Query in Dune aus, exportiere CSV
4. Claude analysiert die CSV und findet Patterns

Das ist ein Produktivitäts-Multiplikator. Was früher eine Stunde SQL-Debugging war, ist jetzt 10 Minuten.

Wichtiger Punkt — die Grenzen

On-Chain-Analyse kann viel — aber sie kann nicht:

• Die Identität hinter Wallets aufdecken (außer bei bekannten, öffentlich markierten Adressen)
• Zukünftige Preis-Bewegungen vorhersagen (siehe dazu den Crypto-Bot-Artikel)
• Off-Chain-Deals sehen (OTC-Handel, CEX-interne Trades, Fiat-Flows)

Wer On-Chain-Daten über-interpretiert als Trading-Signal, läuft in Fehlschlüsse rein. Die Daten sind wertvoll für Kontext-Verständnis und Pattern-Erkennung, nicht für Signale.

Der rechtliche Rahmen

Öffentliche Blockchain-Daten analysieren ist in Deutschland legal. Die Daten sind by design öffentlich. Du darfst aber:

• Nicht personenbezogene Daten rekonstruieren (z.B. über Heuristiken eine Wallet einer natürlichen Person zuordnen und dann publizieren)
• Nicht gezielt Wallets von Privatpersonen publizieren ohne deren Zustimmung
• Nicht Marktmanipulation betreiben (z.B. gefakte Whale-Signale verbreiten)

Für Pentesting-Kontext im weiteren Sinn (Compliance-Audits, AML-Research, interne Analysen) ist alles davon unproblematisch.

Meine Use-Cases

• Projekt-Evaluation vor Investment: Wie sieht die Token-Verteilung aus? Gibt es Wash-Trading? Sind die Top-Holder aktiv?
• Due Diligence für Bekannte: Wenn ein Freund "sollte ich in XYZ investieren" fragt, kann ich in 10 Minuten die wichtigsten roten Flaggen checken.
• Einfach Verständnis: Wer kauft wann was, wenn große Nachrichten kommen? Das Gefühl für den Markt verbessert sich über Zeit.

Weiterlesen

Der Praxis-Test mit echtem Geld: Crypto-Bot 30 Tage Autopilot. Die Steuer-Dimension: Krypto-Steuer 2026. Für die KI-Analyse-Methoden allgemein siehe MCP-Server-Artikel — die Pipelines hier lassen sich auch als MCP-Server ausliefern.

Eigene On-Chain-Tools im Bau? Zone "Crypto Trading" im Discord.