Baue einen Bitfinex-Lending-Bot in Python

Was wir bauen

Einen Bot, der den USD-Funding-Markt beobachtet, ein Angebot 10% über der aktuellen Flash Return Rate (FRR) ruhen lässt und die Kreditnehmer-Nachfrage zu sich kommen lässt. Dieses eine Verhalten — immer ein Angebot über dem Markt ruhen lassen — ist der Kern der meisten Funding-Strategien, denn Rate-Spikes sind zu kurz, um ihnen manuell hinterherzujagen.

Voraussetzungen: Python 3.10+, pip install requests, ein Bitfinex-Konto und $150+ im Funding-Wallet (das Börsen-Minimum pro Angebot). Alles Weitere folgt unten.

Schritt 0: ein Key, der dir nicht wehtun kann

Erstelle den API-Key auf Bitfinex (API Keys → Create New Key) mit genau diesen Scopes: Margin Funding read + write, Wallets read, Account Info read. Lass Abhebungen und Trading deaktiviert — ein Lending-Bot braucht sie nie, und ein begrenzter Key bedeutet: Ein geleakter Key kann dein Lending falsch bepreisen, aber dein Konto nicht leerräumen.

Die vollständigen Details Berechtigung für Berechtigung stehen in unserem Bitfinex-API-Guide für Verleiher; die Kurzfassung: Alles in diesem Beitrag funktioniert mit den Scopes oben und nichts darüber hinaus.

Schritt 1: den Markt lesen (kein Key nötig)

Raten sind öffentlich. Der Funding-Ticker liefert die FRR als Tagesrate an Index 0 — mit 365 multiplizieren ergibt den APR. Diese Schleife sind die Augen des Bots:

Lass sie laufen und du hast einen Live-Raten-Feed. Zwei Konventionen, die du jetzt verinnerlichen solltest: Jede Bitfinex-Rate ist eine Tagesrate (0.0003 ≈ 10.95% APR), und jede Rate ist brutto — die Börse behält 15% der verdienten Zinsen, multipliziere also mit 0.85 für das, was in deinem Wallet ankommt.

                
                  import requests, time

PUB = "https://api-pub.bitfinex.com"

def frr_apr(symbol: str = "fUSD") -> float:
    ticker = requests.get(f"{PUB}/v2/ticker/{symbol}", timeout=10).json()
    return ticker[0] * 365 * 100  # index 0 = FRR, a daily rate

while True:
    print(f"FRR now: {frr_apr():.2f}% APR")
    time.sleep(300)  # poll every 5 minutes — stay well inside rate limits
                
              

Schritt 2: ein signiertes Angebot platzieren

Schreibzugriffe erfordern Authentifizierung: HMAC-SHA384 über den Pfad, eine streng steigende Nonce und den JSON-Body. Das ist die gesamte Auth-Schicht — kein SDK nötig:

Die period ist die Kreditlaufzeit in Tagen (2–120). Kurze Laufzeiten halten dich liquide; lange sperren die Rate ein. Der Betrag ist ein String, Minimum $150-Gegenwert. Bekommst du einen nonce: small-Fehler, hat ein anderer Prozess den Key benutzt — immer ein Key pro Prozess.

                
                  import hashlib, hmac, json, time, requests

KEY, SECRET = "your-key", "your-secret"
BASE = "https://api.bitfinex.com"

def auth_post(path: str, body: dict):
    nonce = str(int(time.time() * 1_000_000))  # must strictly increase per key
    raw = f"/api/{path}{nonce}{json.dumps(body)}"
    sig = hmac.new(SECRET.encode(), raw.encode(), hashlib.sha384).hexdigest()
    return requests.post(f"{BASE}/{path}", data=json.dumps(body), timeout=15, headers={
        "bfx-nonce": nonce, "bfx-apikey": KEY, "bfx-signature": sig,
        "content-type": "application/json",
    }).json()

def place_offer(rate_daily: float, amount: str = "150", period: int = 2):
    return auth_post("v2/auth/w/funding/offer/submit", {
        "type": "LIMIT", "symbol": "fUSD",
        "amount": amount, "rate": f"{rate_daily:.8f}", "period": period,
    })
                
              

Schritt 3: die Strategieschleife

Jetzt der eigentliche Bot: Ruht nichts, platziere ein Angebot 10% über der aktuellen FRR und warte. Kreditnehmer-Nachfrage füllt es bei Ratenschüben; sonst liegt es einfach da. Das ist eine grobe Version eines Perzentil-Floors — ein fester Aufschlag statt eines regimebewussten:

Das ist ein funktionierender Lending-Bot. Er wird tatsächlich Funding-Zinsen verdienen, und in ruhigen Wochen wird er dich nicht blamieren. Er ist aber auch, ganz bewusst, der Anfang der Geschichte statt ihr Ende.

                
                  def tick():
    apr = frr_apr()
    # naive floor strategy: rest 10% above the current FRR and wait to be hit
    target_daily = (apr * 1.10) / 365 / 100
    offers = auth_post("v2/auth/r/funding/offers/fUSD", {})
    if not offers:                      # nothing resting -> place one
        place_offer(target_daily)
    # a real bot also reprices stale offers, sizes per wallet balance,
    # handles partial fills, retries 429s, and survives restarts

while True:
    tick()
    time.sleep(600)
                
              

Was diese 60 Zeilen nicht tun

Die ehrliche Liste — jeder Punkt ist eine Stelle, an der Hobby-Bots leise sterben:

• Strategie. „FRR + 10%“ ist willkürlich. Sollte der Floor das 96. Perzentil der letzten 60 Tage sein? Solltest du 120 Tage einsperren, wenn die Raten regime-hoch sind? Das gut zu beantworten erfordert das Replayen von Regeln gegen Jahre von Daten — das ist der Unterschied zwischen einem Skript und einer Strategie.
• Repricing. Ein ruhendes Angebot veraltet, wenn sich der Markt bewegt. Produktions-Bots repricen kontinuierlich gegen das aktuelle Buch, ohne sich Fills wegzuchurnen.
• State und Neustarts. Absturz mitten in der Schleife und Neustart: Welche Angebote gehören dir? Was wurde gefüllt, während du weg warst? Börsen-State gegen Intention abzugleichen ist der Großteil des Codes eines echten Bots.
• Fehlerbehandlung. 429-Rate-Limits, 5xx-Antworten, WebSocket-Abbrüche, Nonce-Kollisionen, Teil-Fills, vorzeitig zurückgezahlte Kredite — jedes braucht eine Entscheidung, keine unbehandelte Exception um 3 Uhr nachts.
• Buchhaltung. Deine echte Rendite lebt im Ledger (Zinsgutschriften minus 15%-Gebühr), nicht in der Rate, die du angeboten hast. Ledger-Einträge pro Zahlung abzugleichen macht Ertrags- und Steuerzahlen erst real.

Tutorial-FAQ