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: 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
| Model | Latency | Server Load | Reliability |
|---|---|---|---|
| REST API (pull) | 1-5 sec | High (frequent polls) | Medium |
| WebSocket (push) | <50 ms | Low (subscription) | High |
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
| Stage | Duration | Result |
|---|---|---|
| Analytics and requirements gathering | 1-2 days | Technical specification |
| Architecture design | 2-3 days | Data schema, API contracts |
| Implementation | 5-7 days | Source code, test coverage |
| Testing + QA | 2-3 days | Test report |
| Deployment and training | 1-2 days | Documentation, instructions, system access |
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
Example trigger configuration
To set up an alert via Telegram bot, send command /newalert price_above BTCUSDT 50000. The bot will create a rule and return an ID. If you want to combine conditions, use JSON rules via API.
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.