KI-Trading-Bot (Crypto / Revolut X)

KI-gestützter Trading-Bot für Kryptowährungen. Aktueller Stand: Grundgerüst, Backtesting und Paper-Trading laufen – noch keine echten Orders.

Börse ist Revolut X (MiCA-lizenziert über Revolut Digital Assets Europe Ltd, Cyprus/CySEC-Lizenz 001/2025). Ursprünglich war Kraken vorgesehen (ebenfalls MiCA-lizenziert), aber Michael hat bereits ein Revolut-X-Konto – daher der Wechsel.

Kein ccxt: Revolut X wird von ccxt nicht unterstützt. Das offizielle SDK (github.com/revolut-engineering/revolut-x-api) ist zudem TypeScript-only ("Zero runtime dependencies — Node.js built-ins only"), kein Python-SDK vorhanden. Der RevolutXClient in diesem Projekt ist ein eigener Nachbau, 1:1 aus dem TypeScript-Quellcode portiert (Ed25519-Signierung, siehe src/revolut_x_client.py).

Revolut X hat außerdem einen offiziellen MCP-Server für Claude Code & Co. (Marktdaten, Kontoverwaltung, Monitoring, Grid-Backtests) – der ist aber absichtlich read-only für Orders ("cannot place, modify, or cancel orders"). Für automatisierten Handel führt daher kein Weg an der direkten REST-API vorbei, wie sie dieses Projekt nutzt.

Projektstruktur

crypto-trading-bot/
├── README.md
├── requirements.txt                       # Python-Abhängigkeiten
├── .env.example                           # Vorlage für Zugangsdaten (kopieren nach .env)
├── .gitignore                             # schließt auch *.pem aus (Private Key!)
├── crypto-paper-trader.service            # systemd-Unit: einfache Strategie, Paper-Trading
├── crypto-confluence-paper-trader.service # systemd-Unit: Confluence-Strategie, Paper-Trading
├── crypto-grid-paper-trader.service       # systemd-Unit: Grid-Strategie, Paper-Trading
├── crypto-dashboard.service               # systemd-Unit für das Dashboard (alle drei Strategien)
├── templates/
│   ├── dashboard.html                     # Dashboard: einfache Strategie
│   ├── confluence_dashboard.html          # Dashboard: Confluence-Strategie (Legs, Long/Short)
│   └── grid_dashboard.html                # Dashboard: Grid-Strategie (Stufen-Belegung)
├── scripts/
│   └── generate_keypair.py                # erzeugt das Ed25519-Schlüsselpaar
└── src/
    ├── config.py                 # lädt Einstellungen aus .env
    ├── revolut_x_client.py       # Revolut-X-REST-Client (Ed25519-Auth)
    ├── market_data.py            # Ticker & Kerzen als DataFrame
    ├── indicators.py             # RSI, MACD, ATR, EMA (via `ta`)
    ├── strategy.py                # generate_signals() - einfache RSI+MACD-Strategie
    ├── confluence_strategy.py     # generate_confluence_signals() - EMA200+MACD+RSI, long/short
    ├── backtest.py                # Backtest (vectorbt) fuer die einfache Strategie
    ├── confluence_backtest.py     # Backtest (eigener Event-Loop) fuer die Confluence-Strategie
    ├── grid_backtest.py           # Backtest fuer die Grid-Strategie (viele Trades, feste Preisstufen)
    ├── paper_trading.py           # Dauerbetrieb: einfache Strategie, virtuelles Portfolio
    ├── confluence_paper_trading.py # Dauerbetrieb: Confluence-Strategie, virtuelles Portfolio (Legs)
    ├── grid_paper_trading.py      # Dauerbetrieb: Grid-Strategie, virtuelles Portfolio (Stufen)
    ├── dashboard.py               # Flask-Dashboard fuer alle drei Strategien (/, /confluence, /grid)
    └── main.py                   # Smoke-Test / Einstiegspunkt

Setup

Voraussetzung: Python 3.10+.

# 1. Ins Projektverzeichnis wechseln
cd crypto-trading-bot

# 2. Virtuelle Umgebung anlegen und aktivieren
python -m venv .venv
# Windows:
.venv\Scripts\activate
# Linux/Mac:
source .venv/bin/activate

# 3. Abhängigkeiten installieren
pip install -r requirements.txt

# 4. Ed25519-Schlüsselpaar erzeugen
python scripts/generate_keypair.py
# -> Inhalt von public.pem bei Revolut X hinterlegen (Profil > API Keys)
# -> die dort angezeigte API-Key-ID gleich griffbereit halten

# 5. Zugangsdaten anlegen
cp .env.example .env
# .env öffnen: REVX_API_KEY (aus Schritt 4) eintragen,
# REVX_PRIVATE_KEY_PATH zeigt standardmäßig auf ./private.pem

Erster Start

python src/main.py

Wichtig: Anders als bei Kraken hat Revolut X keine öffentlichen Endpunkte – jeder Aufruf (auch reine Marktdaten wie Ticker/Kerzen) braucht eine gültige Ed25519-Signatur. Ohne Schritt 4+5 aus dem Setup läuft der Smoke-Test nicht durch.

Bei Erfolg zeigt er: aktuellen Ticker fürs Standard-Paar (BTC-USD), die letzten Stundenkerzen, und den Kontostand.

Sicherheit (wichtig!)

• .env und private.pem niemals committen – beide stehen in .gitignore. private.pem autorisiert direkt gegenüber der Revolut-X-API – wer ihn hat, kann in deinem Namen handeln.
• DRY_RUN=true ist Standard: Orders sollen nur simuliert/geloggt werden, nicht real ausgeführt. Hinweis: Diese Umschaltung ist aktuell nur als Konfigurationswert vorhanden – die eigentliche Order-Logik (die DRY_RUN auch tatsächlich respektiert) ist noch nicht gebaut, da es noch keine Strategie gibt, die Orders auslöst.
• Revolut X Spot hat kein öffentliches Sandbox/Testnet (soweit bekannt). Sicheres Testen läuft daher über DRY_RUN (sobald implementiert) und später über Backtesting/Paper-Trading.
• Offene Verifikation: Die genaue Zeiteinheit des start-Feldes bei Kerzen (Sekunden vs. Millisekunden) ließ sich aus dem TS-Quellcode nicht eindeutig ableiten – vor echter Nutzung einmal empirisch gegen die echte API prüfen (src/market_data.py geht aktuell von Millisekunden aus).

Backtesting

python src/backtest.py --days 365

Lädt echte historische Kerzen von Revolut X, wendet generate_signals() an (RSI+MACD-Strategie + ATR-basierter Stop-Loss/Take-Profit) und lässt vectorbt.Portfolio.from_signals() das Ergebnis gegen einfaches Buy&Hold rechnen. Wichtige Optionen: --symbol, --interval, --days, --atr-sl-mult, --atr-tp-mult. Speichert einen interaktiven HTML-Plot (backtest_result.html).

Confluence-Backtest (EMA200+MACD+RSI, long/short)

# Einzelnes Symbol
python src/confluence_backtest.py --days 365

# Mehrere Symbole vergleichen (Whitelist standardmaessig auf BTC-USD,LINK-USD begrenzt)
python src/confluence_backtest.py --symbols BTC-USD,ETH-USD,SOL-USD,LINK-USD,AVAX-USD --days 365 --no-whitelist

Eigener bar-für-bar-Event-Loop (kein vectorbt) für die Teil-Take-Profit/ Break-Even-Logik. Wichtige Optionen:

• --symbols (kommagetrennt) für den Multi-Symbol-Vergleich - druckt eine Markdown-Tabelle (Gesamtrendite, Trades, Gewonnen/Verloren, Trefferquote, Max. Drawdown, Profit Factor pro Coin) plus eine gleichgewichtete "Gesamt-Portfolio"-Zeile
• --whitelist (Default BTC-USD,LINK-USD - die beiden Coins mit Profit Factor ≥ 0.95 aus dem Vergleich vom 17.07.2026) schränkt ein, welche Symbole überhaupt getestet werden; --no-whitelist deaktiviert das für explorative Scans
• --min-profit-factor (Default 0.95): Symbole darunter werden automatisch aus der Portfolio-Zeile gesperrt (bleiben aber in der Tabelle sichtbar)
• --risk-pct (Default 0.01 = 1%): Positionsgröße wird risikobasiert über die SL-Distanz berechnet (Risk Parity), nicht mehr "all-in" - ein Stop-Loss kostet dadurch bei jedem Symbol ungefähr denselben Euro-Betrag, unabhängig von dessen Volatilität
• --min-reward-ratio (Default 5.0): Take-Profit-Distanz muss mindestens das 5-fache von (Live-Spread + Rundreise-Gebühr) betragen, sonst wird das Signal verworfen - verhindert, dass die Revolut-X-Kostenstruktur kleine Trades auffrisst

Paper-Trading

Simuliert die exakt gleiche Strategie mit einem virtuellen Portfolio gegen echte Live-Marktdaten - keine echten Orders, aber echte Marktbedingungen. Zustand (Cash, offene Position, Trade-Historie) liegt in data/paper_trading.db (SQLite, lokal, nicht im Git).

# Einmalig im Vordergrund testen
python src/paper_trading.py run --interval-seconds 900

# Dauerbetrieb als systemd-Service
sudo cp crypto-paper-trader.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now crypto-paper-trader

# Aktuellen Stand jederzeit abfragen
python src/paper_trading.py status

Pollt alle 15 Minuten (Default): Stop-Loss/Take-Profit werden gegen den Live-Ticker geprüft (reagiert schneller als eine erst in bis zu einer Stunde geschlossene Kerze), Entry/Exit-Signale nur bei einer neuen, geschlossenen 1h-Kerze - über dieselbe generate_signals()-Funktion wie im Backtest.

Confluence-Strategie: Paper-Trading

Eigenständiger zweiter Paper-Trader für die Confluence-Strategie (EMA200-Trendfilter + MACD-Crossover + RSI "trend-split", long/short, 50%-Teil-Take-Profit + Break-Even-Automation der Resthälfte) - läuft parallel zum einfachen Paper-Trading, eigenes virtuelles Portfolio, eigene SQLite-DB (data/confluence_paper_trading.db). Nutzt dieselbe generate_confluence_signals()-Funktion und dieselben Order-Formeln wie confluence_backtest.py.

python src/confluence_paper_trading.py run --interval-seconds 900

sudo cp crypto-confluence-paper-trader.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now crypto-confluence-paper-trader

python src/confluence_paper_trading.py status

Live-Vereinfachung ggü. Backtest: es gibt keine Kerzen-High/Low für denselben Moment - der aktuelle Live-Preis dient als Näherung für Stop-Loss/ Take-Profit/Break-Even-Prüfung (statt Kerzen-High/Low wie im Backtest).

Wichtig: SHORT-Positionen sind auf einem Revolut-X-Spot-Konto (keine Margin) nicht real handelbar - bleibt rein informative Simulation.

Grid-Strategie: Paper-Trading

Dritter, eigenständiger Paper-Trader für die Grid-Strategie (siehe grid_backtest.py für Herleitung/Backtest-Ergebnisse) - viele kleine "buy low, sell high"-Trades in einer festen Preisspanne statt weniger, seltener Signale. Läuft parallel zu den beiden anderen Strategien, eigenes virtuelles Portfolio, eigene SQLite-DB (data/grid_paper_trading.db).

Die Grid-Spanne wird beim allerersten Start einmalig um den aktuellen Live-Preis berechnet und dauerhaft gespeichert (kein Neuberechnen bei Neustart, sonst würden offene Positionen nicht mehr zu den Stufen passen). Braucht anders als die anderen beiden Strategien keine geschlossenen Kerzen

• reiner Live-Preis-Vergleich gegen die Stufen.

python src/grid_paper_trading.py run --interval-seconds 900 --grid-levels 20 --range-pct 15

sudo cp crypto-grid-paper-trader.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now crypto-grid-paper-trader

python src/grid_paper_trading.py status

Bewusst kein Stop-Loss: bekannte Grid-Schwäche in starkem Trend (alle Stufen bleiben offen/unrealisiert hängen) wird im Dashboard transparent angezeigt statt versteckt.

Dashboard

Kleine Web-Ansicht für alle drei Paper-Trading-Stände: aktuelles virtuelles Kapital, Gesamtrendite, offene Position/Stufen (inkl. unrealisiertem PnL gegen den Live-Preis), Equity-Kurve und Trade-Historie. Liest direkt aus den SQLite-DBs - kein Netzwerk-Umweg zu den Paper-Trading-Prozessen nötig.

• / - einfache RSI+MACD-Strategie
• /confluence - Confluence-Strategie (zeigt beide Legs, Long/Short-Badge)
• /grid - Grid-Strategie (zeigt Stufen-Belegung)

# Einmalig im Vordergrund testen
python src/dashboard.py

# Dauerbetrieb als systemd-Service (Port 8420)
sudo cp crypto-dashboard.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now crypto-dashboard

Nächste Schritte (Roadmap)

• Ersten echten Lauf gegen die echte Revolut-X-API verifiziert (inkl. Candle-Zeiteinheit)
• Erste regelbasierte Strategie (RSI+MACD) + Backtesting (vectorbt)
• Risikomanagement: ATR-basierter Stop-Loss/Take-Profit
• Paper-Trading-Modus (Forward-Test ohne echtes Geld)
• Dashboard für den Paper-Trading-Stand
• Confluence-Strategie (EMA200+MACD+RSI, long/short) + eigenes Paper-Trading
• Strategie in einem anderen Marktregime (Bullenmarkt) validieren
• DRY_RUN tatsächlich in echter Order-Logik verankern, sobald auf reales Trading umgestellt wird
• Order-Ausführung (erst DRY_RUN, dann kleines echtes Kapital)
• Monitoring über Grafana / Benachrichtigungen (Discord-Webhook)
• Steuerliche Einordnung klären (automatisiertes Trading ggf. gewerblich)

Detail-Planung im Vault: 30 Projekte/KI-Trading-Bot Crypto.md.