This is the selection post for LynxCrypto. I originally planned to write my own monitoring bot, but before writing a single line I did a web-wide survey — and found mature off-the-shelf options that are better than what I was going to build. This post lays out all 20+ candidates and explains which one fits me, and why.

0. The Conclusion First (For Those Who Don’t Want the Long Read)

For someone who knows Python, trades OKX perpetuals, and wants “indicator-triggered Telegram alerts + order confirmation inside Telegram”:

• Top pick: Freqtrade (54k stars) — the only project that simultaneously offers “OKX perpetuals + Python indicator-driven strategies + two-way TG commands + button-confirmed order placement (/forcelong /forceshort /forceexit) + dry-run (alerts only, no real trades) + Docker.”
• Alerts only, no orders: Telegram-Crypto-Alerts (105 stars) — config-driven; type a command in TG to create an indicator alert. But it’s tied to Binance and depends on Taapi.io, so OKX requires modification.
• Minimal coding, strong TG interaction: OctoBot (6.5k stars) — config-driven, supports OKX, strong two-way TG control, but lacks per-trade force-enter confirmation.
• Can code, want a perfect OKX fit: ~100 lines of your own with ccxt + pandas-ta + python-telegram-bot — the only option that fits OKX perpetuals exactly, without being locked to any platform’s exchange limitations.

My verdict: it’s not “build it myself vs use something existing” as an either/or. It’s: get Freqtrade’s dry-run + Telegram running first, and light up the full “indicator → alert → confirm → order” loop; once I understand my real needs, then decide whether to customize for OKX.

1. What Do I Actually Want

Before evaluating anything, nail down the requirements — otherwise 20 candidates will spin you in circles:

1. Monitor technical indicators: MACD/RSI/moving-average crossovers, computed on OKX perpetual candles.
2. Push to Telegram on trigger: send me an alert when conditions are met (direction / price / reference stop-loss).
3. Confirm orders inside TG: a real order only goes through when I reply with a command (or tap a button) — not full automation.
4. Self-hosted + Docker: runs on my own WSL2/VPS, behind my local proxy.
5. Mature: real star count, actively maintained, documented — not a toy project.

Filter by these 5 criteria, and out of 20+ candidates only a handful can actually fight.

2. Tier One: The Three That Can Actually Fight

Freqtrade ⭐ 54,048 — The Overall Winner

• URL: https://github.com/freqtrade/freqtrade · GPL-3.0 · still actively committed as of 2026-09-05
• Telegram capability (verified in source freqtrade/rpc/telegram.py): its strongest suit.
  • Push notifications: entries/exits/stop-loss/ROI triggers can all be pushed, each toggled per category.
  • Two-way commands: /status /profit /balance /trades /start /stop /pause.
  • Manually confirmed orders (the core feature): /forcelong <pair>, /forceshort, /forceexit — with inline buttons for second confirmation. Exactly the “confirm in TG before ordering” I wanted.
  • Authorization: an authorized_users whitelist controls who can issue commands.
• OKX perpetuals: ✅ verified in freqtrade/exchange/okx.py; futures supported.
• Alerts without trading: ✅ set dry_run: true — the strategy runs and pushes signals to TG as usual, just never places real orders.
• Deployment: official Docker + docker-compose, pure Python, WSL2-friendly.
• The cost: strategies must be written in Python (the indicator logic). But TG alerts/commands/confirmation are zero-code, out of the box.
• Why it’s the top pick: it’s the only mature project that checks every box — “indicator-driven + OKX perpetuals + two-way TG + button confirmation + dry-run.” All I need to write is the few dozen lines of indicator logic; the alerting and order interaction come for free.

OctoBot ⭐ 6,522 — The Low-Code Alternative

• URL: https://github.com/Drakkar-Software/OctoBot · GPL-3.0 · active as of 2026-09-05
• Telegram capability: rich two-way control commands (/portfolio /open_orders /sell_all /set_risk, etc.), but no Freqtrade-style “force-enter a specific pair + button confirmation” fine-grained order interaction — the TG side leans toward “control and observe,” with orders mainly driven by strategy/TradingView signals.
• OKX perpetuals: ✅ verified in packages/tentacles/Trading/Exchange/myokx/.
• Notable: config-driven — GUI configuration with no code; can install ready-made indicator evaluators, and can also ingest TradingView signals.
• Best for: people who don’t want to write strategy code and can accept “TG control + automatic strategy signals” instead of “per-trade manual confirmation.”

Telegram-Crypto-Alerts ⭐ 105 — The Most On-Target for Pure Alerts

• URL: https://github.com/hschickdevs/Telegram-Crypto-Alerts · MIT · maintained as of 2025-10
• What it is: essentially “a self-hosted TradingView-style indicator alert system + TG slash commands.” Type /new_alert BTC/USDT RSI 4h ... ABOVE 70 in TG and the alert is live; supports RSI/MACD/BBANDS/MA/EMA; Docker self-hosted.
• Two fatal flaws: ① alerts only, no order placement; ② prices come from Binance and indicators from the third-party Taapi.io (requires an API key, has a free tier but isn’t self-contained), and OKX perpetuals are not supported.
• Best for: people who only want alerts and whose instruments are on Binance. OKX users would need to modify it.

3. Stick with TradingView? First Check Whether Webhooks Are Free

They’re not. On TradingView’s official pricing page, “Webhook notifications” is blank for the free (Basic) plan — webhook alerts are a paid feature (Essential/Plus and up). That determines the “keep using TV indicators” route:

Key insight: the TradingView-Screener library gets you TradingView’s officially computed indicator values for free (including precomputed MACD/RSI/MA crossovers) — you don’t even need a market-data API. But it’s just a library: no TG, no Docker; you’d write ~30 lines of scheduled scanning + pushing yourself.

4. Do General-Purpose Self-Hosted Platforms (n8n/Grafana/Huginn) Work?

I did a dedicated pass on “using a general-purpose alerting platform instead of a crypto-specific tool”:

• n8n (203k stars): the closest to “works out of the box” — community Binance/futures nodes pull candles, a built-in Telegram node, but no built-in MACD/RSI computation node; you’d write a small snippet of JS in a Code node to compute indicators. 200k stars, extremely active maintenance, Docker/WSL2/proxy all smooth.
• Grafana (76k stars): great at monitoring, but has no crypto data-source plugin (verified: none among the 356 in the official catalog). You’d poll the OKX API through the Infinity data source, and Grafana alerting is weak at “two lines crossing” (it’s good at thresholds, not crossovers).
• Huginn (49k stars): event-driven, conceptually a good fit, but precise MACD/RSI requires writing a Ruby agent.
• Node-RED (23k stars): flexible, but it’s effectively DIY — indicators must be written in JS function nodes.

Conclusion: among general-purpose platforms n8n is the strongest, but no general-purpose platform can compute MACD/RSI crossovers with zero code — you’re writing a small snippet either way, so why not write it inside something more crypto-native (a Freqtrade strategy, or your own script)?

5. The Eliminated (Also Valuable to Know)

• Hummingbot (19.8k stars): strong trading capability (market making/arbitrage), OKX perpetuals supported, but zero Telegram integration (verified: 0 occurrences of “telegram” in the code tree) — you’d have to build your own alert bridge.
• Jesse (8.4k stars): Telegram is one-way messaging only, no command interaction, and no OKX support (verified: no okx references in the code; only Binance/Bybit/Bitget/Gate).
• A pile of *-signal-bot and RSI/MACD telegram bot repos: almost all 0–3 stars, no license, unmaintained for years — toy projects not worth listing.

6. Final Comparison Table

7. My Decision

Back to LynxCrypto’s reality: MacdCross-4h just passed its final WFO review, and the next step is ant-sized dry-run validation — what I need is exactly the “indicator triggers → TG alert → I confirm → demo order” loop.

Decision: start with Freqtrade.

1. It’s the only one with OKX perpetuals + two-way TG + button confirmation + dry-run all built in — I don’t need to reinvent the wheel.
2. I’ll write MacdCross as a Freqtrade strategy (a few dozen lines of Python), set dry_run: true, and immediately get “signal → TG alert → /forcelong confirmation” running on demo — exactly the validation my Phase 5 calls for.
3. Telegram-Crypto-Alerts can’t be the main tool (tied to Binance, can’t place orders); TradingView-Screener can serve later as a supplementary data source for “multi-coin scanning.”
4. I’m not throwing away the DIY bot I already wrote (run_tg_bot.py) — it proved the “ccxt + self-computed indicators + TG” path works, and if Freqtrade’s constraints ever become a straitjacket, I have a clean fallback.

One sentence: standing on the shoulders of a 54k-star mature project is far smarter than building a bot from scratch that only I will ever use. The time saved goes to the genuinely hard problem — verifying whether the strategy’s edge still exists in live trading.

This series:

• Previous: From a 200-Grid Martingale Grid to Searching for Real Alpha
• Next: I Turned My Strategy into Code, Then Falsified It with My Own Hands
• Tools: Jupyter and the Quant Research Roadmap
• Final review: MacdCross-4h Passes Its WFO Final Review
• This post: selecting a Telegram bot for technical-indicator monitoring

All GitHub star counts, maintenance timestamps, and licenses were verified live via the GitHub API (2026-09-06); OKX perpetual support and Telegram command capabilities were verified against project source code or official documentation. Code lives locally at /home/li/lynxcrypto. Not investment advice.