A_T_S

I Built a Real-Time Crypto Signal Terminal in Python — Here's How It Works
A developer's breakdown of the system architecture, indicator stack, and filtering logic behind a production-grade Binance Futures scanner.
A few months ago I got tired of manually refreshing charts and missing setups while sleeping. So I built my own scanner — a Python terminal that runs on my PC around the clock, watches the top 150 Binance Futures coins, and sends me a Telegram message the moment something worth looking at appears.
No cloud, no subscription, no third-party signal service. Just a script, your own Telegram bot, and a local machine that never stops watching the market.
About Telegram alerts: the system sends notifications directly to your personal Telegram bot — one you create yourself in about 60 seconds via @BotFather. You get a bot token, paste it into the config, and every alert goes straight to your private chat (or any channel you add the bot to). Nobody else sees your signals. No shared group, no middleman.
This article is a technical walkthrough of how the scanner works under the hood.
The Core Problem I Was Solving
Most retail traders either look at one coin at a time, or use signal bots that fire alerts on any RSI cross. Both approaches generate too much noise or miss too much opportunity.
I wanted a system that:
Monitors the full liquid universe of Binance Futures automatically
Uses multiple independent indicator groups that must agree before a signal fires
Assigns a numerical score to every coin so I can rank and prioritize
Runs entirely locally — no cloud, no subscriptions, no data leaving my machine
Architecture: What Runs Every 5 Minutes
The system is a single Python file — Flask for the web layer, NumPy/Pandas for all math, SQLite for persistence, and the Binance REST API for data.
Every 5 minutes:
Fetch the top 150 Binance Futures symbols by 24h volume
Pull 300 OHLCV bars per symbol across 3 timeframes: 15m / 1h / 4h
Run the full indicator stack on each symbol using 12 parallel workers
Score each symbol 0–100, calculate FMQS (Futures Market Quality Score), and determine confidence
Apply 7 signal gates — only signals that pass all gates go to alerts
Push qualified signals to Telegram, Discord, email, and/or webhook
Update the live web dashboard
Full scan of 150 coins completes in roughly 2 minutes. The remaining 3 minutes act as buffer before the next cycle.
20+ Indicators — All Vectorized
Every indicator runs on full Pandas/NumPy arrays — no Python loops over rows. This is what makes scanning 150 coins feasible on a regular PC.
Trend indicators:
EMA ribbon (20/50/100/200)
Supertrend (period 10, multiplier 3.0)
PSAR (Parabolic Stop-and-Reverse)
Ichimoku Cloud (Tenkan / Kijun / Senkou A & B)
ADX (Average Directional Index)
Momentum indicators:
RSI (14-period)
MACD (12/26/9)
Stochastic RSI (smoothed K & D)
Williams %R
CCI (Commodity Channel Index)
Squeeze Momentum (Bollinger Bands vs. Keltner Channel compression)
Volume & market structure:
VWAP anchored to daily open (matches TradingView behavior)
OBV (On-Balance Volume)
Cumulative Delta (taker buy vs. sell volume)
MFI (Money Flow Index)
Order Book Imbalance (bid/ask depth ratio)
Taker Buy/Sell Ratio
Derivatives-specific:
Open Interest momentum (change over last 5 candles)
Funding Rate (current + trend)
Long/Short Ratio
Macro sentiment:
Fear & Greed Index (fetched at scan start, applied to all signals)
300 bars gives enough history for accurate EMA200 calculation and full Ichimoku cloud projection — something many free scanners skip because they only fetch 50–100 candles.
Market Regime Detection
Not all indicators work in all market conditions. A strong RSI overbought reading means something different in a trending market versus a ranging one.
Before scoring, the system classifies each coin's current regime:
TRENDING — ADX > 25, clear directional price structure
RANGING — ADX < 20, price oscillating between visible support/resistance
VOLATILE — high ATR relative to recent average, unpredictable wicks
Each regime activates a different scoring weight profile. In ranging markets, oscillator signals (RSI, Stoch, Williams) get higher weight. In trending markets, trend-following indicators (EMA ribbon, Supertrend, PSAR) dominate.
The FMQS Score
FMQS (Futures Market Quality Score) is a composite filter I built specifically for Binance Futures — it measures whether the derivatives data confirms the spot chart signal.
It combines:
Funding rate direction and magnitude
Open Interest trend (accumulation vs. distribution)
Long/Short ratio skew
Taker buy/sell ratio
A coin can score 80/100 on the technical indicators but get filtered out if the funding rate contradicts the signal direction or if OI is declining while price rises. FMQS must be ≥ 50 to pass.
The 7-Gate Signal Filter
This is the core of why the system doesn't spam alerts.
A signal must pass all 7 gates to fire:
Gate
What it checks
1
Score ≥ minimum threshold (configurable)
2
FMQS ≥ 50
3
Bollinger squeeze not active (false breakout risk)
4
Volume must confirm direction
5
≥ 3 independent indicator groups must agree
6
≥ 2 timeframes must align (confluence)
7
Signal must have appeared in ≥ 1 previous scan (persistence)
Gate 7 is particularly important. A one-scan flash signal — a coin that briefly hits the threshold then disappears — gets filtered. Only signals that show up in consecutive scans pass. This kills the vast majority of noise.
Price Action Filters
The scorer includes a basic candlestick pattern layer that runs on the most recent candles:
Engulfing (bullish/bearish)
Hammer / Pin Bar (long lower wick, rejection of lows)
Shooting Star (long upper wick, rejection of highs)
Morning Star / Evening Star (3-candle reversal)
Inside Bar Breakout
Marubozu (full-body candle, strong directional momentum)
These patterns add score points but don't override the gate system — they're additive, not sufficient on their own.
The system also runs RSI divergence detection across a 35-bar lookback window. Bullish divergence (lower price low, higher RSI low) adds to buy scores. Bearish divergence adds to sell scores.
SL / TP / Risk:Reward — Automatic
For every signal, the system calculates:
Stop Loss — based on ATR and nearest support/resistance level
Take Profit — based on the next resistance/support and historical price structure
Risk:Reward ratio — displayed on the card and in alerts
Signals with R:R below 1.5 are flagged as WEAK even if they pass all gates.
The Live Dashboard
The Flask web server runs locally and serves a real-time UI — one card per coin, updating every 30 seconds.
Each card shows:
Score bars (Score / Confidence / FMQS)
All indicator values (RSI, ADX, MFI, Stoch, CCI, VWAP%, OI%, Taker ratio)
Alignment across 15m / 1h / 4h timeframes
SL / TP / R:R
Mini price chart with support and resistance levels
Live overlays: SL HIT / DANGER / CAUTION / MOVED
Signal strength meter (5 segments)
There's also an OBS-optimized overlay route (/stream) I use during YouTube streams — transparent background, real-time signal cards visible on top of TradingView.
Sound alerts fire on new signals, completed scans, and SL events. Keyboard shortcut R forces an instant refresh.
Multi-Channel Alerts
Every qualified signal fires to your Telegram bot — a visual summary card generated with Pillow, containing score bars, indicator snapshot, SL/TP levels, and market context. The bot supports multiple channels simultaneously, so you can route signals to different chats depending on the coin or signal type.
Setting up takes about two minutes:
Open Telegram, search for @BotFather
Send /newbot, give it a name — BotFather returns your bot token
Paste the token into the terminal config
Start a chat with your bot (or add it to a channel) and grab the chat ID
Run the terminal — alerts arrive automatically
That's it. Signals go only to you — no shared groups, no resellers, no one else sees your setups.
The system also supports Discord webhooks, SMTP email, and generic HTTP webhooks if you want to forward alerts further — but Telegram is the primary channel and works out of the box.
Pro / API Layer
The system exposes a REST API (with optional API key auth) for:
/api/signals — latest qualified signals
/api/status — scanner health, last scan time, top coin
/api/config — read/write config without restarting
/api/export/signals.csv — full signal history
/api/price-alerts — set, list, delete custom price triggers (GET/POST/DELETE)
/health — uptime monitoring endpoint
/api/version — version and feature list
SQLite stores all signal history next to the script file — survives reboots. Cache is tuned to 32MB + 256MB mmap for fast queries.
Technical Stack Summary
Python — Flask, NumPy, Pandas, Pillow, Requests
Data source — Binance Futures REST API (public endpoints, no API key required for scanning)
Database — SQLite with WAL mode
Frontend — Vanilla JS, Canvas API for mini charts
Deployment — runs locally on any PC or laptop, auto-opens browser on launch
Single file. No Docker, no cloud, no external database. Install dependencies, set your Telegram token, run python terminal.py — done.
What This Is and What It Isn't
This is a signal scanner and alert system — not an auto-trader. It shows you setups; you decide whether to take them.
It works best as a second screen tool: let it scan in the background, get a Telegram alert when a high-confidence setup forms, then open TradingView to confirm manually before entering.
If you're a developer or systematic trader interested in this kind of tooling, feel free to reach out.
📩 Telegram: @ATS_binance
Built on Python · Flask · NumPy · Pandas · Binance REST API · SQLite