Traders spend hours manually monitoring charts for volatility spikes. With 500+ pairs, this becomes a daily routine that distracts from decision-making and reduces efficiency. For example, to find an entry moment before an important event, you have to manually scan dozens of windows — it takes 20-30 minutes, and the result is often outdated.
Our cryptocurrency volatility screener is a ready-made web3 trading tool: it aggregates metrics in real time — one glance is enough to see anomalies. The pipeline collects data from Binance, Bybit, and OKX via WebSocket with under 1 second latency. The screener processes 1000+ pairs simultaneously, outputting a sorted list with RV, ATR, and Bollinger Band Width calculations. You can configure filters for your strategy and receive alerts when the desired signal appears. This real-time screener is designed for traders who need fast crypto volatility analysis.
For example, in one project for a hedge fund, we configured a volatility screener for 200 pairs with alerts on RV and volume. In the first week, the system identified three anomalies that led to profitable trades, recouping development costs in a month. This approach lets the trader focus on analysis rather than data gathering.
Problems We Solve
- Fear of missing out. Traders spend hours scanning pairs to find that one spike. The screener delivers a ready list in seconds.
- False signals. Many tools show volatility without context — they don't distinguish noise from trend. Our calculation uses multiple metrics (RV, ATR, BB Width) and an anomaly flag based on Z-score.
- Latency. Standard solutions update every 5 minutes. We use WebSocket and incremental calculation — under 1 second delay.
How We Calculate Volatility Metrics
Let's take realized volatility as an example. It's the foundation, but its calculation can be a bottleneck with 500+ pairs. We use vectorized Pandas operations and Redis aggregation:
import numpy as np
import pandas as pd
def realized_volatility(closes: pd.Series, window: int = 24, annualize: bool = True, periods_per_year: int = 8760) -> pd.Series:
log_returns = np.log(closes / closes.shift(1))
rv = log_returns.rolling(window).std()
if annualize:
rv = rv * np.sqrt(periods_per_year)
return rv * 100
def atr(high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14) -> pd.Series:
prev_close = close.shift(1)
tr = pd.concat([high - low, (high - prev_close).abs(), (low - prev_close).abs()], axis=1).max(axis=1)
return tr.ewm(span=period, adjust=False).mean()
def bollinger_bandwidth(close: pd.Series, window: int = 20, num_std: float = 2.0) -> pd.Series:
rolling_mean = close.rolling(window).mean()
rolling_std = close.rolling(window).std()
return (rolling_mean + num_std * rolling_std - (rolling_mean - num_std * rolling_std)) / rolling_mean * 100
The RV formula is based on the standard deviation of logarithmic returns (Realized Volatility).
Real-Time Screener Architecture
The pipeline is built as follows: Binance/OKX WebSocket → Candle Aggregator → Redis (last N candles) → VolatilityCalculator (every 60 seconds) → PostgreSQL/TimescaleDB → REST API + WebSocket → Frontend (React).
class VolatilityScreener:
def __init__(self, symbols: list[str]):
self.symbols = symbols
async def calculate_screener_data(self) -> list[ScreenerRow]:
results = []
for symbol in self.symbols:
candles = await self.get_candles(symbol, interval='1h', limit=168)
df = pd.DataFrame(candles, columns=['time','open','high','low','close','volume'])
if len(df) < 24:
continue
row = ScreenerRow(
symbol=symbol,
price=float(df.close.iloc[-1]),
change_1h=float(df.close.pct_change(1).iloc[-1]*100),
change_24h=float(df.close.pct_change(24).iloc[-1]*100),
change_7d=float(df.close.pct_change(168).iloc[-1]*100),
rv_1h=float(realized_volatility(df.close, 1, annualize=False).iloc[-1]),
rv_24h=float(realized_volatility(df.close, 24, annualize=False).iloc[-1]),
rv_7d=float(realized_volatility(df.close, 168, annualize=False).iloc[-1]),
atr_percent=float(atr(df.high, df.low, df.close).iloc[-1]/df.close.iloc[-1]*100),
bb_width=float(bollinger_bandwidth(df.close).iloc[-1]),
volume_24h=float(df.volume.iloc[-24:].sum()),
volume_ratio=float(df.volume.iloc[-1]/df.volume.iloc[-24:].mean()),
)
rv_mean = realized_volatility(df.close, 24, annualize=False).mean()
rv_current = row.rv_1h
row.volatility_spike = rv_current > rv_mean * 2.5
results.append(row)
return sorted(results, key=lambda x: x.rv_24h, reverse=True)
Filters for Selecting Crypto Assets
A screener is useless without flexible crypto asset filtering. We implemented: minimum 24h volume, price change over 1h/24h/7d, anomalous volatility flag, BB width (squeeze detection), sector (DeFi, Layer1, meme), and exchange. Sorting by any metric. All in real time via WebSocket.
Want to test the screener on your own data? Contact us — we'll set up a trial version.
Alert System
class VolatilityAlertsEngine:
async def check_alerts(self, symbol: str, current_data: ScreenerRow):
user_alerts = await self.db.get_active_alerts(symbol)
for alert in user_alerts:
triggered = False
if alert.type == 'rv_threshold':
triggered = current_data.rv_24h > alert.threshold
elif alert.type == 'volume_spike':
triggered = current_data.volume_ratio > alert.multiplier
elif alert.type == 'bb_squeeze':
triggered = current_data.bb_width < alert.threshold
elif alert.type == 'price_change':
triggered = abs(current_data.change_1h) > alert.threshold
if triggered and not alert.is_triggered:
await self.send_alert(alert, current_data)
await self.db.mark_alert_triggered(alert.id)
Alerts are delivered via Telegram bot, email, push, and webhook. Important nuance: an alert automatically resets after triggering to avoid missing a repeated spike.
Volatility Metrics Comparison
| Metric | What It Measures | When to Use |
|---|---|---|
| Realized Volatility (RV) | Standard deviation of log-returns | General volatility level, mean-reversion strategies |
| Average True Range (ATR) | Average range (high-low) accounting for gaps | Setting stop-losses, risk assessment |
| Bollinger Bands Width | Normalized band width | Squeeze detection (breakout signal) |
Alert Types Comparison
| Alert Type | Trigger | Example Use Case |
|---|---|---|
| Realized Volatility (RV) threshold | RV_24h > threshold | Detecting extreme volatility |
| Volume Spike | Volume > multiplier × average volume | Trend start detection |
| BB squeeze | BB Width < threshold | Preparing for breakout |
| Price change | Price change > threshold over 1h | Capturing momentum |
Our screener processes 500+ pairs in 2 seconds — 3 times faster than typical Flask solutions. In one project, we deployed the screener for a hedge fund, allowing them to identify momentum ideas in 10 minutes instead of 2 hours daily, saving $50,000 per month on analytics. Another fund saved $25,000 per month after implementing our screener. In yet another project, reduced analysis time led to monthly savings of $30,000.
Technical Scaling Details
To support 1000+ pairs, we use Redis Pub/Sub for distributing candle data among workers, and metric calculation runs in a separate process using multiprocessing.Pool. The TimescaleDB database stores metric history for backtesting.What's Included in Volatility Screener Development
- Architectural documentation — pipeline schema, metric and filter descriptions.
- Python backend (FastAPI) with exchange integration and metric calculation.
- Web3 frontend (React + TypeScript) with real-time table and charts.
- Alert system (Telegram, email, webhook).
- Deployment on your infrastructure or cloud.
- Team training and developer documentation.
Over 5 years specializing in volatility screener development and building web3 trading tools for the crypto market; delivered 40+ projects for traders and funds. We guarantee pipeline performance under load of 1000+ pairs.
Process
- Analysis — discuss metrics, filters, alerts.
- Design — choose the stack, design architecture.
- Implementation — write code, set up CI/CD.
- Testing — load testing, comparison with reference data.
- Deployment and documentation handover.
Timeline: 4 to 6 weeks depending on complexity. Cost is determined individually. Contact us to discuss your scenario. Request a free consultation — we'll evaluate your project.
Advice: Don't try to cover all metrics at once. Start with one (RV or ATR), ensure the pipeline is stable, then add filters and alerts. This reduces time to launch by 2-3 weeks.