# Krypto-Trading-Bot mit KI bauen: Testnet bis VPS

URL: https://agentvera.dev/de/blog/build-crypto-trading-bot-with-ai/ · Veröffentlicht: 2026-10-11

Krypto-Trading-Bot mit KI bauen: Python und ccxt, Testnet, Backtesting, API-Schlüssel nur zum Handeln, Logging, VPS und Telegram-Alerts, mit ehrlichen Risikohinweisen.

**Kurz gesagt:**

- Der Beitrag ist keine Finanzberatung und weist darauf hin, dass die meisten Bots Geld verlieren; der Bot entsteht in Python mit ccxt, Strategie-, Risiko- und Order-Code liegen in getrennten Modulen.
- Risikoregeln: höchstens 2 % des Guthabens pro Order, Stopp bei 5 % Tagesverlust und ein API-Schlüssel, der nur lesen und handeln darf, ohne Auszahlungen und mit IP-Whitelist.
- Backtest mit 0,1 % Gebühr und 0,05 % Slippage gegen Buy-and-Hold, mindestens ein paar Tage im Testnet laufen lassen, dann mit dem kleinsten Betrag live gehen.

Einen Krypto-Trading-Bot mit KI zu bauen ist heute wirklich einfach: Ein Coding-Agent wie Claude Code oder Codex kann einen Python-Bot schreiben, der sich über ccxt mit einer Börse verbindet, eine einfache Strategie ausführt und Orders platziert. Die eigentliche Arbeit steckt in allem rund um den Code: Tests im Testnet und in Backtests, ein API-Schlüssel, der nur handeln darf, und der Umstieg auf echtes Geld mit winzigen Beträgen.

Diese Anleitung führt Schritt für Schritt von einem leeren Ordner zu einem Bot, der rund um die Uhr auf einem Server läuft und dir Telegram-Alerts schickt. Zuerst aber der Teil, bei dem ich ehrlich sein muss.

## Zuerst das Risiko: Das ist keine Finanzberatung

Dies ist ein Software-Tutorial, keine Anlageberatung. Ein paar Fakten vorab:

- **Die meisten Trading-Bots verlieren Geld.** Besonders die einfachen Strategien aus dem Netz, sobald Gebühren, Slippage und plötzliche Kursbewegungen eingerechnet sind.
- **Eine Strategie, die im Backtest großartig aussieht, versagt live oft.** Strategien, die auf vergangene Daten zugeschnitten sind (Overfitting), brechen schnell zusammen.
- **KI-geschriebener Code kann teure Fehler enthalten.** Eine falsche Mengeneinheit, eine vertauschte Kauf-/Verkaufsbedingung oder eine Retry-Schleife, die immer weiter Orders platziert, kann ein Konto in Minuten leeren.
- **Gib einem Bot nur Geld, dessen Verlust du verkraften kannst.** Starte im Testnet, dann geh live mit dem kleinsten Betrag, den die Börse erlaubt.

Die Strategie in diesem Beitrag ist ein Code-Beispiel. Ich stelle sie nicht als Weg dar, Geld zu verdienen.

## Welchen Stack du wählst

Wenn du einen Bot per [Vibe Coding](/de/glossary/vibe-coding/) baust, wähle den Stack, den der Agent am besten kennt. Meine Wahl:

- **Python 3.11+**: das ausgereifteste Ökosystem für Daten (pandas), Backtesting und Börsenbibliotheken, und die Sprache, in der Agenten die meisten Beispiele gesehen haben.
- **ccxt**: eine Open-Source-Bibliothek, die über eine einheitliche Schnittstelle mit vielen Börsen spricht. Für eine Börse geschriebener Code lässt sich meist mit wenigen geänderten Zeilen auf eine andere übertragen, und sie unterstützt den Testnet-/Sandbox-Modus vieler Börsen.
- **pandas**: um Kerzendaten (OHLCV) als Tabelle zu bearbeiten.
- **python-dotenv**: um API-Schlüssel in einer `.env`-Datei zu halten, nicht im Code.
- **SQLite**: um offene Positionen und Orders festzuhalten, ohne einen Datenbankserver zu betreiben.

Einrichtung:

```bash
mkdir crypto-bot && cd crypto-bot
git init
python3 -m venv .venv && source .venv/bin/activate
pip install ccxt pandas python-dotenv requests
echo ".env" >> .gitignore
echo ".venv/" >> .gitignore
```

Füge diese `.gitignore`-Zeilen in der ersten Minute hinzu. Ein versehentlich auf GitHub gepushter API-Schlüssel ist der häufigste und teuerste Fehler in diesem ganzen Bereich.

## Schritt 1: ein Testnet-Konto und ein richtig eingeschränkter API-Schlüssel

Viele große Börsen bieten eine Testumgebung (Testnet oder Sandbox), in der kein echtes Geld fließt. Suche in der Entwicklerdokumentation der Börse nach „testnet“ oder „sandbox“ und lege dort ein eigenes Testkonto und einen Test-API-Schlüssel an. Gibt es kein Testnet oder fehlt dein Paar dort, lassen wir den Agenten einen Paper-Trading-Modus bauen, der echte Preise liest, Orders aber nur lokal aufzeichnet.

Wenn du später einen Schlüssel für das echte Konto erstellst:

- **Aktiviere nur Lesen und Handeln. Aktiviere nie Auszahlungen.** Wenn der Schlüssel geleakt wird, kann niemand dein Guthaben woandershin senden.
- **Nutze IP-Whitelisting.** Wenn die Börse es unterstützt, binde den Schlüssel an die statische IP deines VPS.
- **Lass Futures und Margin deaktiviert.** Beginne mit Spot.
- **Lege pro Bot einen eigenen Schlüssel an**, damit du nur diesen widerrufen kannst, falls etwas schiefgeht.

Eine `.env`-Datei sieht so aus:

```bash
EXCHANGE=binance
API_KEY=your-test-key
API_SECRET=your-test-secret
USE_TESTNET=true
TELEGRAM_TOKEN=
TELEGRAM_CHAT_ID=
```

Füge diese Werte nicht in den Chat mit dem Agenten ein. Der Agent muss wissen, dass `.env` existiert, nicht, was darin steht.

## Schritt 2: der erste Prompt

Öffne den Agenten im Projektordner (`claude` oder `codex`) und bitte um den Bot in Schichten, nicht alles auf einmal. Ein erster Prompt zum Kopieren:

```text
Set up a skeleton for a simple spot trading bot in Python 3.11 with ccxt.
Rules:
- Read settings from .env with python-dotenv. Never open or print .env.
- If USE_TESTNET=true, enable ccxt sandbox mode; otherwise print a
  "LIVE MODE" warning on start and wait 10 seconds.
- Modules: config.py, exchange.py (connection, balance, candles, orders),
  strategy.py (returns a signal, never places orders), risk.py (position
  size, daily loss limit), bot.py (main loop), storage.py (SQLite log).
- Every order must pass risk.py first. Max 2% of balance per order;
  stop the bot if the daily loss exceeds 5%.
- With DRY_RUN=true, never place orders, only log them.
- Use Python logging to logs/bot.log and the console.
- No strategy yet: strategy.py should always return "hold".
When done, summarize the file layout and how to run it.
```

Warum zuerst ein Grundgerüst? Wenn Strategie, Order-Platzierung und Risikoregeln in getrennten Dateien liegen, lässt sich der Code leichter prüfen und Fehler fallen eher auf. Kann die Strategie keine Orders platzieren, erzeugt ein Fehler dort schlimmstenfalls ein falsches Signal, und die Risikoschicht begrenzt den Schaden.

## Schritt 3: eine Beispielstrategie (Kreuzung gleitender Durchschnitte)

Noch einmal: Das ist ein Beispiel, kein Rat. Eine Kreuzung gleitender Durchschnitte ist eine der klarsten Strategien, um die Struktur zu zeigen. Kreuzt der schnelle Durchschnitt den langsamen von unten nach oben, signalisiert das „buy“; kreuzt er nach unten, „sell“.

```python
# strategy.py — example only, not financial advice
import pandas as pd

def signal(ohlcv: list, fast: int = 20, slow: int = 50) -> str:
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    if len(df) < slow + 2:
        return "hold"
    df["fast"] = df["close"].rolling(fast).mean()
    df["slow"] = df["close"].rolling(slow).mean()
    prev, last = df.iloc[-3], df.iloc[-2]  # the last candle is still open, skip it
    if prev.fast <= prev.slow and last.fast > last.slow:
        return "buy"
    if prev.fast >= prev.slow and last.fast < last.slow:
        return "sell"
    return "hold"
```

Ein Detail, das auffallen sollte: Das Signal wird aus der letzten geschlossenen Kerze berechnet, weil die neueste noch in Bewegung ist. Agenten übersehen das oft, und der Bot springt dann innerhalb einer Kerze hin und her.

Prompt, um sie hinzuzufügen:

```text
Add a 20/50 moving average crossover to strategy.py. Compute signals from
closed candles only. Write pytest tests for the signal function: cross up,
cross down, not enough data and a flat market. Run the tests and show me
the output.
```

## Schritt 4: Backtesting

Bevor du live gehst, lass die Strategie auf historischen Daten laufen. Du kannst den Agenten Kerzen mit ccxt holen und eine einfache Backtest-Schleife schreiben lassen. Für Ernsteres schau dir backtesting.py, vectorbt oder Freqtrade an; Freqtrade ist ein ausgereiftes Open-Source-Bot-Framework, das Backtesting, Dry Run und Telegram-Steuerung schon mitbringt.

Ein Prompt:

```text
Write backtest.py. Fetch the last year of BTC/USDT 1h candles with ccxt,
paginating, and save them as CSV under data/. Apply strategy.signal candle
by candle without looking ahead. Deduct 0.1% fee and 0.05% slippage per
trade. Report total return, number of trades, win rate, max drawdown and
buy-and-hold return over the same period.
```

Beim Lesen der Ergebnisse:

- **Rechne immer Gebühren und Slippage ein.** Ohne sie sieht fast jede Strategie gut aus.
- **Vergleiche mit Buy-and-Hold.** Schneidet der Bot schlechter ab als bloßes Halten, lohnt der Aufwand nicht.
- **Prüfe Look-ahead-Bias selbst.** Lies die Schleife und stelle sicher, dass sie nie Daten nutzt, die es noch nicht gab.
- **Dreh nicht so lange an den Parametern, bis die Kurve schön aussieht.** Wenn 17/43 besser abschneidet als 20/50, ist das höchstwahrscheinlich Zufall.

## Schritt 5: Testnet und Paper Trading

Lass den Bot nach dem Backtest mindestens ein paar Tage im Testnet laufen:

```bash
DRY_RUN=false USE_TESTNET=true python bot.py
```

In dieser Phase prüfst du das Verhalten, nicht den Gewinn. Gehen Orders mit der richtigen Menge raus? Erinnert sich der Bot nach einem Neustart an eine offene Position? Stürzt er ab, wenn die Börse einen Fehler zurückgibt, oder wartet er und versucht es erneut? Greift das Tagesverlustlimit tatsächlich?

Löse absichtlich einen Fehler aus, zum Beispiel eine Order, die größer ist als dein Guthaben, und sieh zu, wie der Bot ihn sauber loggt und stoppt.

## Schritt 6: Rate Limits, Fehlerbehandlung und Logging

Börsen begrenzen API-Anfragen. Ein Bot, der sie überschreitet, bekommt zuerst Fehler und wird bei weiterem Drauflosfeuern möglicherweise vorübergehend gesperrt. Die ccxt-Option `enableRateLimit` verteilt Anfragen automatisch; lass den Agenten bestätigen, dass sie aktiv ist.

```text
Review exchange.py:
- Make sure ccxt enableRateLimit is on.
- On NetworkError and RateLimitExceeded, retry up to 5 times with
  increasing backoff. On InsufficientFunds and InvalidOrder, do not retry;
  log it and send a Telegram alert.
- Log the request, exchange response and order id for every order.
- Prevent a second order for the same signal (idempotency).
```

Eine gute Logzeile beantwortet später die Frage „Warum hat der Bot das getan?“: Zeit, Signal, Preis, berechnete Menge, Ergebnis der Risikoprüfung, Order-ID. Logge nie API-Schlüssel oder Secrets.

## Schritt 7: Telegram-Alerts

Der Bot sollte dir sagen, was er tut. Am einfachsten geht das mit einem schlichten HTTP-Aufruf an die Telegram Bot API:

```python
# notify.py
import os, requests

def send(text: str) -> None:
    token, chat = os.getenv("TELEGRAM_TOKEN"), os.getenv("TELEGRAM_CHAT_ID")
    if not token or not chat:
        return
    try:
        requests.post(f"https://api.telegram.org/bot{token}/sendMessage",
                      json={"chat_id": chat, "text": text}, timeout=10)
    except requests.RequestException:
        pass  # a failed alert must not stop the bot
```

Den Token bekommst du über Telegrams offiziellen Ablauf zum Erstellen von Bots. Ereignisse, die einen Alert wert sind: Bot gestartet/gestoppt, Order platziert, Fehler, Tagesverlustlimit erreicht. Mein Leitfaden zum [Telegram-Bot mit KI bauen](/de/blog/build-telegram-bot-with-ai/) zeigt, wie du Befehle ergänzt, etwa um den Bot aus der Ferne zu stoppen.

## Schritt 8: rund um die Uhr auf einem VPS laufen lassen

Geht dein Laptop in den Ruhezustand, tut es der Bot auch. Ein kleiner Linux-VPS genügt; eine statische IP ist für die IP-Whitelist wichtig.

### Mit systemd

```ini
# /etc/systemd/system/crypto-bot.service
[Unit]
Description=Crypto bot
After=network-online.target

[Service]
User=bot
WorkingDirectory=/home/bot/crypto-bot
EnvironmentFile=/home/bot/crypto-bot/.env
ExecStart=/home/bot/crypto-bot/.venv/bin/python bot.py
Restart=on-failure
RestartSec=30

[Install]
WantedBy=multi-user.target
```

```bash
sudo systemctl daemon-reload
sudo systemctl enable --now crypto-bot
journalctl -u crypto-bot -f
```

Lass den Bot unter einem eigenen Benutzer laufen, nicht als root, und sichere die Env-Datei mit `chmod 600 .env`.

### Mit Docker

Wenn du Docker bevorzugst, lass den Agenten ein `Dockerfile` und eine `docker-compose.yml` schreiben, mit `restart: unless-stopped`, `env_file` für `.env` und Volumes für `logs/` und die SQLite-Datei, damit Bot und Aufzeichnungen einen Server-Neustart überstehen.

## Häufige Fehler: was die KI gern falsch macht

- **Mengen und Präzision.** Börsen erzwingen pro Paar eine Mindestmenge und eine Dezimalpräzision. Agenten überspringen das und bekommen abgelehnte Orders oder runden falsch. Lass sie `amount_to_precision` von ccxt und die Markt-Limits verwenden.
- **Die offene Kerze nutzen.** Signale aus einer Kerze, die sich noch bewegt, sind Rauschen.
- **Testnet-Flag in Produktion an gelassen oder beim Testen aus.** Logge den Modus beim Start deutlich.
- **Zustand beim Neustart verlieren.** Vergisst der Bot eine offene Position, kauft er womöglich erneut. Halte den Zustand in SQLite und gleiche ihn beim Start mit der Börse ab.
- **Orders in einer Retry-Schleife.** Umschließt die Retry-Logik das Platzieren der Order, kann dieselbe Order viele Male rausgehen.
- **Verschluckte Fehler.** Überall `except: pass` ergibt einen Bot, der lebendig aussieht und nichts tut.
- **„Tests bestanden“ blind vertrauen.** Sieh dir die Ausgabe selbst an.

## Sicherheits-Checkliste

- API-Schlüssel liegen nur in `.env`, und `.env` steht in `.gitignore`.
- Füge Schlüssel nie in den Agenten, einen Chat oder einen Screenshot ein.
- Auszahlungen aus, IP-Whitelist an, Margin aus.
- Lies die Befehle, die der Agent ausführen will, bevor du zustimmst, besonders alles, was `.env` liest, Dateien hochlädt oder Netzwerkaufrufe macht.
- Wenn du vermutest, dass ein Schlüssel geleakt ist, widerrufe ihn sofort bei der Börse und erstelle einen neuen.
- Aktiviere Zwei-Faktor-Authentifizierung für das Börsenkonto.
- Installiere nur Abhängigkeiten, die du kennst; prüfe jeden Paketnamen, den der Agent vorschlägt und von dem du noch nie gehört hast.

## So mache ich das mit AgentVera

Bei solchen Projekten lasse ich mehrere Agenten nebeneinander laufen. In einem [AgentVera](/de/features/workspace/)-Raster kann Claude Code in einem Worktree an Strategie und Backtest arbeiten, während Codex in einem anderen die Telegram-Alerts und Docker-Dateien baut, ohne dass sie sich in die Quere kommen. Nach jedem Turn lässt das [automatische Code-Review](/de/features/code-review/) ein zweites Modell lesen, was der Agent geschrieben hat; das ist ein nützliches zweites Augenpaar bei Mengenrechnungen und Kauf-/Verkaufsbedingungen. Du prüfst den Diff im [Git-Panel](/de/features/git-and-github/), bevor du mergst, und siehst die [Token-Nutzung](/de/features/token-savings/) pro Agent. Ist der Bot fertig, bringt [SSH und SFTP](/de/features/ssh-and-sftp/) die Dateien auf den VPS, und der [Docker-Manager](/de/features/docker/) zeigt den Container lokal.

Nichts davon ist Pflicht; zwei Terminals und Git funktionieren auch. Wenn dich das parallele Setup interessiert, lies [parallele Coding-Agenten](/de/blog/parallel-coding-agents/).

## Fazit

Die Coding-Seite beim Bau eines Krypto-Trading-Bots mit KI kostet ein paar Stunden: Python, ccxt, klar getrennte Module, eine Risikoschicht und gute Logs. Was Zeit braucht und wirklich zählt, ist das Testen: Backtest, Testnet, Paper Trading und erst dann ein winziger Live-Betrag. Beschränke den API-Schlüssel auf den Handel, schalte Auszahlungen aus und lies jede Order-Zeile, die der Agent schreibt. Und denk daran, dass die meisten Bots Geld verlieren; baue diesen, um zu lernen, nicht um reich zu werden.

## Häufige Fragen

**Kann KI einen Krypto-Trading-Bot bauen?** Ja. Ein Coding-Agent schreibt an einem Nachmittag einen Python-Bot mit ccxt, der sich mit einer Börse verbindet, eine Strategie ausführt und Orders platziert. Schwierig ist nicht der Code, sondern zu wissen, ob die Strategie Geld verdient und ob der Code einen teuren Fehler versteckt.

**Welche Berechtigungen sollte der API-Schlüssel eines Trading-Bots haben?** Nur Lesen und Handeln; aktiviere nie Auszahlungen. Wenn die Börse es unterstützt, beschränke den Schlüssel auf die IP-Adresse des Servers, auf dem der Bot läuft.

**Wie teste ich einen Trading-Bot ohne echtes Geld?** Teste ihn zuerst per Backtest mit historischen Daten, lass ihn dann tagelang im Testnet der Börse oder in einem Paper-Trading-Modus laufen, der Orders nur aufzeichnet. Wechsle erst danach zu echtem Geld, mit einem Betrag, dessen Verlust du verkraftest.

**Verdienen Krypto-Trading-Bots Geld?** Die meisten nicht. Einfache Strategien verlieren nach Gebühren und Slippage meist, und ein gut aussehender Backtest sagt wenig über die Zukunft. Dieser Beitrag ist keine Finanzberatung.

**Wo lasse ich einen Krypto-Bot rund um die Uhr laufen?** Ein kleiner Linux-VPS reicht. Läuft der Bot als systemd-Dienst oder Docker-Container, startet er nach einem Absturz neu und seine Logs liegen an einem Ort.

---

**Über AgentVera.** AgentVera ist eine Desktop-App für macOS, Windows und Linux, entwickelt von Solviera Teknoloji. Sie führt 18 KI-Coding-Agenten (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) nebeneinander aus, pro Projekt, in echten Terminals mit den eigenen CLI-Installationen und Logins des Nutzers. Der kostenlose Plan hat unbegrenzt viele Agenten. Download: https://agentvera.dev/de/download/ · Preise: https://agentvera.dev/de/pricing/