⚡ Advanced Integration INSTITUTIONAL

Overview

Webhooks allow you to receive real-time notifications when liquidation events occur. Configure webhooks in your Institutional dashboard.

Event Types

• liquidation.zone_created - New liquidation zone detected
• liquidation.zone_updated - Zone strength or position count changed
• liquidation.position_near - Position entered near-liquidation range
• liquidation.event_occurred - Liquidation event triggered

Webhook Payload

{
  "event": "liquidation.event_occurred",
  "timestamp": 1686744000000,
  "data": {
    "symbol": "BTC",
    "type": "long",
    "price": 45000.00,
    "positions_liquidated": 127,
    "total_liquidation_value": 12500000,
    "sources": ["hyperliquid", "gains"]
}

Setup Instructions

1. Log into your Institutional dashboard
2. Navigate to Integrations → Webhooks
3. Add your webhook endpoint URL (must be HTTPS)
4. Select event types to subscribe to
5. Test webhook delivery

Streaming Data

For real-time integration with your data pipeline:

# Python example
from liquidator_api import Client

client = Client(api_key="your_key")

# Stream liquidation events
for event in client.stream_liquidations(symbol="BTC"):
    process_event(event)

Batch Processing

For batch analysis of historical data:

# Get all positions from last 24 hours
positions = client.get_positions(
    symbol="BTC",
    start_time="2026-01-14T10:30:00Z",
    end_time="2026-01-15T10:30:00Z"
)

for position in positions:
    analyze(position)

Risk Management Pattern

Use Liquidator Analytics to inform risk management:

• Monitor liquidation zones near current price
• Adjust position sizing based on zone strength
• Set stop losses above/below major liquidation zones
• Reduce leverage in high-concentration zones

Example Bot Logic

def calculate_position_size(symbol, leverage):
zones = client.get_ml_zones(symbol)

# Find nearest liquidation zone
nearest_zone = min(zones, key=lambda z: abs(z['price'] - current_price))

# Reduce size if in high-concentration zone
if nearest_zone['strength_score'] > 80:
    leverage *= 0.5
    return calculate_size(leverage)

Schema for Liquidation Data

CREATE TABLE liquidations (
  id STRING,
  timestamp BIGINT,
  symbol STRING,
  type STRING, -- 'long' or 'short'
  price DECIMAL,
  concentration DECIMAL,
  source STRING, -- exchange code
  zone_strength INT,
  confidence DECIMAL
);

ETL Pipeline

Daily ETL to sync historical data:

• Extract: Pull liquidation data from API
• Transform: Normalize timestamps, clean data
• Load: Insert into data warehouse

Feature Engineering

Use liquidation data as features in your models:

• Zone Proximity: Distance to nearest liquidation zone
• Zone Strength: ML signal strength score
• Concentration: Position cluster density
• Historical Volatility: Past price movements at zones

Model Training

import pandas as pd
from liquidator_api import Client

client = Client(api_key="key")

# Collect historical data
data = []
for symbol in ["BTC", "ETH", "SOL"]:
    zones = client.get_ml_zones(symbol, lookback="30d")
    for zone in zones:
        data.append
        ({
            "symbol": symbol,
            "zone_strength": zone["strength_score"],
            "volatility": zone["volatility"],
            "price_move_next_hour": calculate_return(symbol)
        })

df = pd.DataFrame(data)
model.fit(df)

Alerting Rules

Configure alerts for critical events:

• Zone strength exceeds threshold
• Position concentration increases rapidly
• Price approaching strong liquidation zone
• Major liquidation event detected

Integration with Monitoring

# Send alerts to Slack, PagerDuty, etc
def on_liquidation_event(event):
    if event["positions_liquidated"] > 1000:
        alert.slack
        (
            f"Large liquidation: {event['symbol']} "
            f"at {event['price']}"
        )

Caching Strategy

• Cache zone data for 30 seconds
• Cache ML signals for 60 seconds
• Invalidate on webhook events

Connection Pooling

Use HTTP connection pooling for efficient API usage:

from liquidator_api import Client

# Connection pooling built-in
client = Client
    (
        api_key="key",
        pool_size=10 # Tune for your load
    )