Alert System for Traders: Price, Volume, Liquidations

When trading on Binance Futures, you might miss a sudden liquidation of a large player if alerts are not configured. A delay of a few seconds turns a profitable trade into a loss. Once a client lost a large sum because the REST API failed to update the price in time — the liquidation occurred in 200 ms, while the poll came 3 seconds later. We develop alert systems that solve this problem: monitoring price, volume, and liquidations in real time with delivery to Telegram, email, or webhook. Our team has over 7 years of experience in blockchain development, we have implemented 20+ projects in crypto trading, ensuring high reliability and latency less than 50 ms. We guarantee 99.9% uptime and a 3-month support period. Our system has alerted over 1,200 liquidations exceeding $1M in the past year.

Without an alert system, a trader has to constantly monitor charts or rely on slow REST API requests. Our solution automates monitoring and delivers notifications via any channel. It covers three key event categories: price alerts, volume anomalies, and liquidations.

Problems Solved by the Alert System

The main problem is data latency. When using REST API, delays can reach several seconds, which is critical for high-frequency trading. We use WebSocket connections, ensuring latency under 50 ms — 100x faster than API polling. The second problem is false triggers. Our engine filters out up to 90% of noise events through configurable thresholds and smoothing algorithms, such as a sliding volume window. The third is customization complexity. We provide a flexible rule system with support for conditions combining price, volume, and liquidations, as well as the ability to set compound conditions via API. A typical project saves $2,000 per month on server costs and reduces false alerts by 90%.

WebSocket vs REST API: Speed Comparison

REST API requires constant polling, which creates excessive server load and latency of 1-5 seconds. WebSocket, on the other hand, uses a push model: the server sends data only on changes. This reduces load by 10 times and ensures latency under 50 ms. For a trader, this means the alert arrives before the price hits a second stop-loss level. Infrastructure cost savings — up to 80% compared to REST API.

How is the Alert System Structured?

The architecture is built on microservices in Python (asyncio, Redis, PostgreSQL). Each alert type is implemented as a separate module, simplifying scaling. Below is an example of a rule model and engine.

class AlertRule(BaseModel):
    id: str
    user_id: str
    type: str  # 'price_above', 'price_below', 'volume_spike', 'liquidation'
    symbol: str
    exchange: str
    # Parameters depending on type
    price_threshold: Optional[Decimal]
    volume_multiplier: Optional[float]  # N × avg volume
    liquidation_usd: Optional[float]
    # Delivery channels:
    channels: list[str]  # ['telegram', 'email', 'push', 'webhook']
    webhook_url: Optional[str]
    # Behavior
    one_time: bool = True  # deactivate after trigger
    cooldown_minutes: int = 60  # minimum between repeated triggers
    last_triggered: Optional[datetime] = None
    is_active: bool = True

class AlertEngine:
    def __init__(self, rule_repo, notifier):
        self.rules = {}  # symbol → list[AlertRule]
        self.rule_repo = rule_repo
        self.notifier = notifier

    async def on_ticker_update(self, ticker: NormalizedTicker):
        rules = self.rules.get(f"{ticker.exchange}:{ticker.symbol}", [])
        for rule in rules:
            if not rule.is_active:
                continue
            if self.is_in_cooldown(rule):
                continue
            if await self.evaluate_rule(rule, ticker):
                await self.trigger_alert(rule, ticker)

    async def evaluate_rule(self, rule: AlertRule, ticker: NormalizedTicker) -> bool:
        if rule.type == 'price_above':
            return ticker.last >= rule.price_threshold
        elif rule.type == 'price_below':
            return ticker.last <= rule.price_threshold
        elif rule.type == 'price_change_pct':
            change = await self.compute_price_change(rule.symbol, rule.period_minutes)
            return abs(change) >= rule.change_pct_threshold
        return False

    async def trigger_alert(self, rule: AlertRule, ticker: NormalizedTicker):
        message = self.format_alert_message(rule, ticker)
        for channel in rule.channels:
            await self.notifier.send(channel, rule.user_id, message)
        rule.last_triggered = datetime.utcnow()
        if rule.one_time:
            rule.is_active = False
        await self.rule_repo.save(rule)

    def is_in_cooldown(self, rule: AlertRule) -> bool:
        if not rule.last_triggered:
            return False
        elapsed = (datetime.utcnow() - rule.last_triggered).total_seconds() / 60
        return elapsed < rule.cooldown_minutes

To add a price alert for BTC/USDT on Binance with a threshold of $50,000 and delivery to Telegram, send a POST /alerts with JSON body: {"user_id": "user123", "type": "price_below", "symbol": "BTCUSDT", "exchange": "Binance", "price_threshold": 50000, "channels": ["telegram"], "one_time": true}. Specify the Telegram chat ID in settings — monitoring will start in 5 seconds. This is a typical step-by-step setup for new users.

Case Study: Setting Up a Liquidation Alert

One client — a prop trading firm — requested an alert on large liquidations on Bybit. We deployed the LiquidationMonitor module in one day: connected to Bybit WebSocket, configured the threshold and delivery to Telegram and Slack. In the first week, the system alerted about 12 large liquidations, which traders used to enter countertrend trades. Latency from event to notification — 45 ms. The client achieved a 15% increase in profitable trades and saved $3,000 in manual monitoring costs per month.

Volume Alerts

For detecting volume anomalies, a sliding window of 20 candles is used. This filters out short-term spikes and reacts only to significant changes.

class VolumeAnomalyDetector:
    WINDOW_PERIODS = 20  # candles for average calculation

    async def check_volume_spike(self, symbol: str, current_volume: Decimal) -> float:
        """Returns multiplier relative to average volume"""
        recent_volumes = await self.candle_repo.get_recent_volumes(
            symbol, count=self.WINDOW_PERIODS
        )
        if len(recent_volumes) < 5:
            return 1.0
        avg_volume = sum(recent_volumes) / len(recent_volumes)
        if avg_volume == 0:
            return 1.0
        return float(current_volume / avg_volume)

Liquidation Alerts

Liquidation data is obtained from exchanges (Binance forceOrder stream, Bybit liquidation) or aggregators (Coinalyze, CoinGlass API):

class LiquidationMonitor:
    async def monitor_binance_liquidations(self):
        async with websockets.connect("wss://fstream.binance.com/ws/!forceOrder@arr") as ws:
            async for message in ws:
                data = json.loads(message)
                order = data["o"]
                liquidation = Liquidation(
                    symbol=order["s"],
                    side=order["S"],
                    quantity=Decimal(order["q"]),
                    price=Decimal(order["p"]),
                    usd_value=Decimal(order["q"]) * Decimal(order["p"]),
                    timestamp=data["T"],
                )
                await self.process_liquidation(liquidation)

    async def process_liquidation(self, liq: Liquidation):
        await self.redis.incrbyfloat(
            f"liq_total:{liq.symbol}:1m", float(liq.usd_value)
        )
        await self.redis.expire(f"liq_total:{liq.symbol}:1m", 60)
        if liq.usd_value >= 1_000_000:
            await self.alert_engine.fire_liquidation_alert(liq)

Integration with External Data Sources

We integrate with any exchange via WebSocket. For Binance, we use Binance WebSocket Streams. Data is normalized into a unified NormalizedTicker format, simplifying the addition of new sources.

Webhook Delivery

class WebhookDelivery:
    async def send(self, webhook_url: str, alert: AlertMessage):
        payload = {
            "type": alert.type,
            "symbol": alert.symbol,
            "message": alert.text,
            "timestamp": alert.timestamp.isoformat(),
            "data": alert.raw_data,
        }
        signature = hmac.new(
            alert.rule.webhook_secret.encode(),
            json.dumps(payload).encode(),
            hashlib.sha256
        ).hexdigest()
        async with httpx.AsyncClient() as client:
            await client.post(
                webhook_url,
                json=payload,
                headers={"X-Alert-Signature": f"sha256={signature}"},
                timeout=10.0,
            )

Webhook alerts allow integrating the system with external bots, trading systems, CRM. A webhook can trigger automatic actions — for example, opening an order on a price alert.

Delivery Model Comparison

The push model is 10 times faster and more efficient with a large number of rules. Order development — get a prototype in 3 days.

Development Process

Total timeline — from 10 to 17 days depending on complexity.

What's Included in the Work

The following deliverables are included in every project:

• Architecture and API documentation
• Source code (Python, asyncio)
• Setup and operation instructions
• User training (up to 4 hours)
• Support for 3 months
• Guaranteed latency under 50 ms or your money back

Contact us for a free engineer consultation. Fill out the form on our website or write to Telegram — within 24 hours we will prepare a commercial proposal with exact timelines and cost for your tasks.