Market-Making-Strategien — Liquidität bereitstellen mit Smart Money Insights

Market Maker profitieren von Bid-Ask-Spreads, indem sie beide Seiten der Liquidität bereitstellen. Im Krypto-Bereich ist dies bei richtiger Anwendung risikoarm: Sie können den Bestand minimieren, indem Sie auf einer anderen Börse hedgen und die Spread-Differenz einstreichen. Smart Money API hilft Market Makern, Spreads dynamisch basierend auf Wal-Aktivität und Funding-Rate-Anomalien anzupassen.

Wesentliche Erkenntnis: Professionelle Market Maker weiten Spreads aus, wenn große Orders erwartet werden (basierend auf Wal-Positionsänderungen). Sie verengen Spreads, wenn der Momentum nachlässt. Smart Money-Signale ermöglichen es Ihnen, diesen Änderungen vorzugreifen.

Grundlagen des Market Makings

Der Spread

Sie kaufen zum Bid-Preis und verkaufen zum Ask-Preis. Ihr Gewinn ist die Differenz:

Gewinn pro Round-Trip = Ask - Bid

Bei BTC/USDT zu $42.000:

Bestandsrisiko

Wenn Sie 1 BTC zu $42.000 kaufen, aber der Preis auf $41.000 fällt, bevor Sie verkaufen, haben Sie $1.000 Verlust. Erfahrene Market Maker hedgen dies:

Python — Bestandsabsicherung
# Kauf auf Bybit zum Bid, sofortiger Verkauf auf Binance zum Ask
buy_bybit(symbol="BTCUSDT", size=1, side="buy", limit_price=41978.95)
sell_binance(symbol="BTCUSDT", size=1, side="sell", limit_price=42050)
# Gewinn = 42050 - 41978,95 = 71,05 USDT, unabhängig von der Preisbewegung
# Risiko besteht nur in der Ausführung: Was, wenn Ihr Verkaufsorder nicht ausgeführt wird?

Dynamische Spread-Strategien

1. Market Making mit festem Spread

Einfachste Methode: Immer 1bp auf beiden Seiten quotieren.

Python — Market Making mit festem Spread
def fixed_spread_mm(mid_price, spread_bps=1.0):
spread = mid_price * (spread_bps / 10000)
bid = mid_price - (spread / 2)
ask = mid_price + (spread / 2)
return {"bid": bid, "ask": ask}

2. Volatilitätsangepasster Spread

Spreads bei hoher Volatilität ausweiten, bei ruhigen Märkten verengen:

Python — Volatilitätsangepasstes Market Making
def volatility_adjusted_mm(mid_price, returns_1h, confidence_score):
# 1-Stunden-Volatilität berechnen (Standardabweichung der Renditen)
vol = np.std(returns_1h)
# Basis-Spread: 1bp
base_spread_bps = 1.0
# Mit Volatilität multiplizieren (Skala 0-10x)
vol_multiplier = 1 + (vol * 50) # Hohe Volatilität = weiterer Spread
# Mit Konfidenz multiplizieren (wenn Smart Money HIGH ist, leicht verengen)
if confidence_score > 0.65:
confidence_mult = 0.8 # um 20% verengen
else:
confidence_mult = 1.0
final_spread_bps = base_spread_bps * vol_multiplier * confidence_mult
spread = mid_price * (final_spread_bps / 10000)
return {
"bid": mid_price - (spread / 2),
"ask": mid_price + (spread / 2),
"spread_bps": final_spread_bps
}

3. Smart Money-reaktive Spreads

Spreads basierend auf Wal-Aktivitätssignalen anpassen:

Python — Wal-reaktives Market Making
def smart_money_adjusted_spreads(symbol, mid_price):
# Smart Money-Signal abrufen
sm = get_smart_money_signal(symbol)
# HOHE Konfidenz + bullisch = Markt bewegt sich bald nach oben
# Ask ausweiten (Hoffnung auf besseren Verkaufspreis)
# Bid verengen (schnellere Ausführung auf der Kaufseite)
if sm["confidence"] == ] == "HIGH" and sm["direction"] == ] == "long"::
bid_spread = 0.8 # 0,8bp auf Bid (wettbewerbsfähig)
ask_spread = 1.4 # 1,4bp auf Ask (auf Ausführung drängen)
elif sm["confidence"] == ] == "VETO"::
bid_spread = 2.0 # auf beiden Seiten weit (Unsicherheit)
ask_spread = 2.0
else::
bid_spread = 1.0 # normal symmetrisch
ask_spread = 1.0
return {
"bid": mid_price - (mid_price * bid_spread / 10000),
"ask": mid_price + (mid_price * ask_spread / 10000)
}

Bestandsmanagement

Zielbestand

Legen Sie einen neutralen Bestandszielwert fest (z.B. 0 BTC). Wenn Sie zu viel ansammeln, erhöhen Sie den Bid (drängen auf Verkauf). Wenn Sie zu short sind, erhöhen Sie den Ask (drängen auf Kauf):

Python — Bestandsabweichung
def get_inventory_skew(current_inventory, target_inventory=0):
skew = current_inventory - target_inventory
# Bei zu hohem Bestand (+1 BTC), Gebot weiter stellen, um zu verkaufen
if skew > 0:
bid_adjustment = min(skew * 0.5, 2.0) # bis zu 2bp hinzufügen
ask_adjustment = -min(skew * 0.5, 1.0) # um bis zu 1bp straffen
# Bei Short-Position, Nachfrage weiter stellen, um zu kaufen
elif skew < 0:
ask_adjustment = min(abs(skew) * 0.5, 2.0)
bid_adjustment = -min(abs(skew) * 0.5, 1.0)
else:
bid_adjustment = 0
ask_adjustment = 0
return bid_adjustment, ask_adjustment

Produktions-Market-Maker

Python — Vollständiges MM-System
class CryptoMarketMaker:
def __init__(self, symbol, inventory_target=0):
self.symbol = symbol
self.inventory = 0
self.inventory_target = inventory_target
def update_quotes(self, mid_price):
# 1. Smart Money-Signal abrufen
sm = get_smart_money_signal(self.symbol)
# 2. Volatilitätsanpassung
vol = calculate_volatility_1h(self.symbol)
# 3. Bestandsanpassung
inv_bid, inv_ask = get_inventory_skew(self.inventory)
# 4. Alle Faktoren kombinieren
base_bid, base_ask = fixed_spread_mm(mid_price, 1.0)
vol_bid, vol_ask = volatility_adjusted_mm(mid_price, [vol], sm["composite"])
sm_bid, sm_ask = smart_money_adjusted_spreads(self.symbol, mid_price)
# Durchschnitt der angepassten Preise
final_bid = np.mean([base_bid, vol_bid, sm_bid]) + inv_bid
final_ask = np.mean([base_ask, vol_ask, sm_ask]) + inv_ask
# Orders platzieren
submit_order(side="bid", price=final_bid, size=1)
submit_order(side="ask", price=final_ask, size=1)

Optimieren Sie Ihr Market Making mit Smart Money-Signalen

Market Maker, die ihre Spreads basierend auf Wal-Aktivität und Smart Money-Konfidenz anpassen, erzielen 15-25 % bessere Ausführungspreise und reduzieren das Bestandsrisiko.

Algo-Zugang erhalten →