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 für genau das.
Hinweis zu den Zahlen: Die genannten Analyse-Ergebnisse (z. B. Wash-Trading-Anteile) sind illustrative Größenordnungen, die die Methode veranschaulichen — keine Messwerte aus einem bestimmten Datensatz. Führ die Scripts gegen aktuelle On-Chain-Daten selbst aus, um belastbare Zahlen zu bekommen.
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:
- Etherscan für die Top-100-Holder-Liste einer Token-Contract-Adresse
- 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 eine Telegram-Nachricht, wenn eine der gewatchten Wallets etwas 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.
Lässt man das Script über eine Stichprobe neuer Meme-Coins laufen, landet erfahrungsgemäß ein erheblicher Teil bei Wash-Scores über 60 (illustrativ: grob die Hälfte). Das ist keine Randerscheinung — auffällige Volumen-Muster sind im Meme-Coin-Segment eher der Normalfall als die Ausnahme. Die konkrete Quote hängt von Stichprobe und Zeitraum ab, also selbst nachmessen.
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. Ein bewährter Workflow:
- Beschreibung an Claude: "Ich will die 20 aktivsten Solana-Wallets der letzten 7 Tage, die mit Jupiter DEX interagiert haben."
- Claude generiert DuneSQL
- Query in Dune ausführen, CSV exportieren
- Claude analysiert die CSV und findet Patterns
Das ist ein Produktivitäts-Multiplikator. Was früher eine Stunde SQL-Debugging war, sind jetzt eher zehn 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.
Typische Use-Cases
- Projekt-Evaluation vor Investment: Wie sieht die Token-Verteilung aus? Gibt es Wash-Trading? Sind die Top-Holder aktiv?
- Schnelle Due Diligence: Bei der Frage "sollte man in XYZ investieren" lassen sich in wenigen Minuten die wichtigsten roten Flaggen checken.
- Markt-Verständnis: Wer kauft wann was, wenn große Nachrichten kommen? Das Gefühl für den Markt verbessert sich mit der Zeit.
Weiterlesen
Was ein Trading-Bot realistisch leistet: Krypto-Bot auf 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.
