Bouw een Bitfinex lending bot in Python

Wat we gaan bouwen

Een bot die de USD-fundingmarkt in de gaten houdt, één offer 10% boven de huidige Flash Return Rate (FRR) laat rusten, en de vraag van leners naar zich toe laat komen. Dat ene gedrag — altijd een offer boven de markt laten liggen — is de kern van de meeste fundingstrategieën, omdat rentepieken te kort zijn om handmatig achterna te jagen.

Vereisten: Python 3.10+, pip install requests, een Bitfinex-account en $150+ in de funding wallet (het minimum per offer van de exchange). Al het andere staat hieronder.

Stap 0: een key die je geen pijn kan doen

Maak de API-key aan op Bitfinex (API Keys → Create New Key) met exact deze scopes: Margin Funding read + write, Wallets read, Account Info read. Laat opnames en trading uitgeschakeld — een lending bot heeft ze nooit nodig, en een key met beperkte scopes betekent dat een gelekte key je uitleenprijzen kan verpesten, maar je account niet kan leegtrekken.

Alle details per permissie staan in onze Bitfinex API-gids voor uitleners; de korte versie is dat alles in dit artikel werkt met de scopes hierboven en niets meer.

Stap 1: lees de markt uit (geen key nodig)

Rentes zijn publiek. De funding-ticker geeft de FRR terug als dagrente op index 0 — vermenigvuldig met 365 voor APR. Deze loop is de ogen van de bot:

Draai hem en je hebt een live rentefeed. Twee conventies om nu al te verinnerlijken: elke Bitfinex-rente is per dag (0.0003 ≈ 10.95% APR), en elke rente is bruto — de exchange houdt 15% van de verdiende rente, dus vermenigvuldig met 0.85 voor wat er in je wallet belandt.

                
                  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
                
              

Stap 2: plaats een ondertekend offer

Schrijfacties vereisen authenticatie: HMAC-SHA384 over het pad, een strikt oplopende nonce, en de JSON-body. Dit is de complete auth-laag — geen SDK nodig:

De period is de looptijd van de lening in dagen (2–120). Korte looptijden houden je liquide; lange zetten de rente vast. Het bedrag is een string, minimaal het equivalent van $150. Krijg je een nonce: small-fout, dan heeft een ander proces de key gebruikt — één key per proces, altijd.

                
                  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,
    })
                
              

Stap 3: de strategieloop

Nu de eigenlijke bot: als er niets rust, plaats een offer 10% boven de huidige FRR en wacht. De vraag van leners vult het tijdens rentestuwingen; anders blijft het liggen. Dit is een ruwe versie van een percentielbodem — een vaste opslag in plaats van een regimebewuste:

Dat is een functionerende lending bot. Hij zal echt fundingrente verdienen, en in rustige weken zal hij je niet voor schut zetten. Hij is ook, met opzet, het begin van het verhaal in plaats van het einde.

                
                  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)
                
              

Wat deze 60 regels niet doen

De eerlijke lijst — elk punt is waar hobbybots stilletjes sneuvelen:

• Strategie. "FRR + 10%" is willekeurig. Moet de bodem het 96e percentiel van de laatste 60 dagen zijn? Moet je 120 dagen vastzetten als de rentes regime-hoog staan? Dat goed beantwoorden vereist het afspelen van regels tegen jaren aan data — dat is het verschil tussen een script en een strategie.
• Repricing. Een rustend offer veroudert terwijl de markt beweegt. Productiebots herprijzen continu tegen het actuele boek zonder fills weg te jagen.
• State en herstarts. Crash midden in de loop en herstart: welke offers zijn van jou? Wat is gevuld terwijl je plat lag? Exchange-state afstemmen op intentie is het grootste deel van de code van een echte bot.
• Foutafhandeling. 429-rate-limits, 5xx-responses, WebSocket-drops, nonce-botsingen, gedeeltelijke fills, vroegtijdig terugbetaalde leningen — elk vereist een beslissing, geen onafgehandelde exception om 3 uur ’s nachts.
• Boekhouding. Je werkelijke rendement leeft in het grootboek (rentecreditten minus de 15% fee), niet in de rente die je aanbood. Het reconciliëren van grootboekregels per uitbetaling maakt winst- en belastingcijfers echt.

Tutorial-FAQ