CROT — CryptoRoboTrading — is an open-source Python bot for USDT-M perpetual futures. Its common engine keeps execution safety, exchange transport, state, and telemetry separate from switchable strategy plugins. Free to use, inspectable end to end, and honest about the risks.
Futures trading involves substantial risk of loss. This is software, not financial advice.
If you have only used the bot constructors built into exchanges, think of this as the next level of control. Instead of picking a grid template and a few sliders, you run a full trading program on your own machine, connected to your exchange account (HTX today) through official API keys. Everything it does is visible: the source code, the configuration, and a line-by-line log of every trade decision.
Runs on your PC or a small VPS. Your API keys stay in a local file on your machine — they are never uploaded anywhere, never logged, and never committed to version control. Funds remain in your own exchange account at all times.
Choose a strategy plugin by name. Its typed settings, documented ranges, and optional TOML overrides are validated before the engine can contact the exchange; typos and unsafe values fail loudly instead of silently keeping an old default.
SQLite is the primary analytical store for trade events, cycles, signals, diagnostics, candidates, and market candles. Read-only reports, replay, and forward labeling let you evaluate a strategy on evidence rather than marketing claims.
| Exchange constructors (grid / DCA templates) |
This bot (standalone, open source) |
|
|---|---|---|
| Strategy logic | Fixed templates, a few sliders | Full multi-layer strategy: trend, pullback, trigger, quality gates, ranking |
| Tunable parameters | Typically 5–15 | Typed per-strategy manifest, validated TOML overrides, JSON Schema output |
| Source code | Closed — you trust the exchange's black box | Open source (MIT) — audit every line before you fund it |
| Stop-loss | Varies; often software-side or absent | Reduce-only hard stop placed on the exchange from entry — active even if your server dies |
| Exchange lock-in | Total — the bot lives and dies with that exchange | The strategy and risk engine are yours; HTX today, built on CCXT to add exchanges |
| Records & analytics | Summary numbers in a dashboard | SQLite WAL telemetry, JSONL fallback, read-only reports and replay tools |
| Cost | Often subscription or profit share | Free. You pay only normal exchange fees |
| What you provide | Nothing — it runs on their servers | A machine that stays on (any PC or a ~$5/mo VPS) and basic terminal comfort |
The last row is the honest trade-off: you host it yourself. In exchange, you get full control, full transparency, and zero recurring fees.
Version 1.3 is an architecture release, not a bundle of new presets. Storage, private exchange transport, market data, configuration, runtime safety, research, tests, and deployment have all changed so strategies can evolve independently from the engine.
Versioned hooks, state schema, capabilities, and a stable StrategyContext.
Signed account, position, and order calls for HTX's current private surface.
strategy_state.STRATEGY=btc_countertrend_grid_v1 selects the current default.ema_pullback_lermont keeps the earlier EMA approach in an isolated, attributed adapter.xsec_reversion_v1 is an experimental measurement package, while example_minimal is the developer template. External packages can register through Python entry points.depth.step6 and shares the cache across long and short profiles..env; each plugin declares typed defaults and optional, range-checked TOML overrides.build.sh, Docker image, deployment healthcheck, and strategy-agnostic conformance suite support repeatable installs.Maker-first entry. A five-rung post-only grid can shed unfundable rungs or fall back to one passive order without inflating risk to meet exchange minimums.
Economic preflight. Reward versus fees, spread, stop distance, rounded contracts, minimum notional, margin, and portfolio caps are checked before an order is sent.
Exchange-truth exits. A maker target, exchange-side protection, fresh-BBO confirmation, uncovered-remainder IOC, and a bounded time exit replace cached-price assumptions.
Account-wide guardrails. Planned risk, directional and portfolio exposure, margin, notional, daily loss, and high-water drawdown are enforced as a cascade.
The architecture and automated tests can be validated offline. That does not prove live activation, exchange-side protection on a particular account, or profitability; those require separate operational evidence, and futures remain high risk.
Version 1.3 defaults to BTC Countertrend Grid, but the earlier EMA Pullback
approach is still selectable as ema_pullback_lermont. It trades pullbacks in
an established trend: the plugin identifies the slow trend, waits for a dip and recovery
on faster charts, and then applies its entry-quality pipeline. The walkthrough below
describes that plugin, not a hard-coded engine behavior.
Changing plugins swaps strategy logic and typed strategy state. It does not replace the engine-owned exchange transport, persistence, execution-safety checks, combined lifecycle, or telemetry. That boundary is the central change in version 1.3.
Signals are computed on closed candles only — the bot never reacts to a candle that is still forming, which removes a whole class of false signals.
| Layer | Timeframe | EMAs | Role |
|---|---|---|---|
| Macro trend | 1h | EMA 48 / 120 | Is there a real trend to trade? |
| Pullback | 5m | EMA 24 / 72 | Did price pull back and start recovering? |
| Trigger | 5m | EMA 24 / 72 | Is short-term momentum aligned right now? |
The same logic runs symmetrically in both directions: the long profile buys pullbacks in uptrends, the short profile sells rallies in downtrends. Both run in one process, share market data, and never open opposite positions on the same coin.
An aligned trend is necessary but not sufficient. Before placing a single order, a candidate must clear a pipeline of independent checks:
Entries use a ladder of post-only limit orders placed below the market (above, for shorts) — the bot waits for the price to come to it instead of chasing, and earns maker fees rather than paying taker fees.
Hard limits cap how many new positions can open per signal and per hour. When too many coins signal at once — a classic sign of a market-wide move rather than genuine setups — crowded-market rules tighten every threshold automatically.
Adding to a losing position is the way most bots die. Here averaging is capped at two stages, requires a minimum drawdown scaled by volatility, a minimum time interval, a fresh recovery signal, and respect for all margin caps — or it simply doesn't happen.
Strategy-specific risk rules can vary, but version 1.3 keeps the non-negotiable execution, state, and account safeguards in the common engine.
The common execution layer validates reduce-only closes, reconciles the real position, and treats incomplete visibility of closing orders as a safety problem. Strategies can request protection; they cannot bypass the engine's close-order invariants.
The default grid strategy checks rounded contracts, exchange minimums, reward after estimated costs, stop distance, required margin, and portfolio headroom before it sends an order. A target is never raised merely to make a weak trade pass.
Per-trade planned risk, directional risk, total portfolio risk, margin allocation, planned gross notional, open-position count, loss streaks, and cooldowns are checked as separate limits. Passing one never implies passing the rest.
An atomic account-wide sidecar tracks high-water equity, the UTC day boundary, daily loss, and the entry block. If that guard cannot be read or written reliably, new entries fail closed while position protection and exits continue.
A stale WebSocket tick cannot trigger a target. The engine falls back to a fresh, uncached public BBO and otherwise keeps reconciling the position and protection without pretending that an executable exit price was observed.
State is written atomically and reconciled against the exchange after restart. A plugin cannot reinterpret an open position as another strategy's state; incompatible switches fail closed instead of guessing.
Version 1.3 stops mixing secrets, runtime wiring, and trading decisions in one giant file. The selected plugin owns its typed defaults; an optional TOML override is validated before startup and recorded in diagnostics.
.env; trading parameters live with the selected strategy package.
STRATEGY selects a
package globally, so long and short cannot silently run incompatible logic or state.
# .env — runtime wiring
STRATEGY=btc_countertrend_grid_v1
BOT_PROFILES=long,short
STRATEGY_CONFIG=config/conservative.toml
SQLITE_ENABLED=true
# config/conservative.toml — strategy overrides
leverage = 20
risk_per_trade_pct = 0.02
max_simultaneous_positions = 6Most trading tools show you a PnL number and ask you to trust it. This bot records the full context of every decision and ships the tools to analyze that record with real statistical methods.
SQLite stores typed trade events, cycle statistics, signal analytics, diagnostics, candidate decisions, and market candles. Full sanitized JSON payloads preserve new strategy fields; rich JSONL remains an emergency human-readable trail.
Read-only reports can point at the active database or a verified snapshot. Replay, forward labels, horizon reports, hold-time studies, factor diagnostics, and candle archives make hypotheses reproducible without writing to the trading database.
Separate engine, strategy, analysis, and conformance tests run on mocks and stubs without a live API. Generated engine-surface docs and schema checks fail when the plugin contract drifts — repository validation remains deliberately separate from live verification.
Four steps. Budget an evening for it: most of the time goes into reading the configuration comments and the launch checklist — which is exactly how it should be.
HTX is the exchange the bot supports today, so you need an HTX account with USDT-M futures enabled. If you don't have one yet, you can register with invite code 6hc25223 — a referral that supports this project at no cost to you. Set the account to cross margin, one-way position mode.
In HTX account settings, create an API key with futures trading permission and withdrawals disabled. The key goes into a local file on your machine and nowhere else.
Clone the repository, install dependencies into a virtual environment, and copy the example config:
git clone https://github.com/Lermont/HTX-crypto-bot.git
cd HTX-crypto-bot
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env # then add your API keys and coin listRun the test suite, keep the default conservative caps, and start with budgets you are comfortable watching closely for the first days:
python -m pytest -q # all tests should pass
python bot.py # runs both long and short profilesThe repository includes a full pre-launch checklist covering leverage verification, margin mode, and safe first-run budgets. Read it.
No one can promise that, and we won't. The strategy is built to control downside first — hard stop-losses, margin caps, throttled entries — and to document every decision it makes so you can judge it on real data. Markets change, and any strategy can have losing periods. Start with small budgets, review the logs, and scale only when the numbers earn your trust.
Not to run a bundled strategy. Secrets and infrastructure settings live in .env; strategy selection is one named value, and optional tuning uses a validated TOML file. You should be comfortable with basic terminal commands, running the test suite, and editing text files. Writing a new strategy plugin does require Python.
On any machine you control with Python 3.11 or newer — your home PC, a mini-PC, or a small cloud VPS (a $5/month instance is plenty). Because it trades continuously, most users run it on an always-on server. A watchdog script is included to restart the bot if it ever stops. Critically, the hard stop-loss is placed on the exchange itself, so your downside protection stays active even if your server goes offline.
Your funds never leave your own HTX account — the bot only sends signed trading orders through the official API. API keys are stored in a local .env file on your machine and are excluded from logs, config snapshots, and version control. Create API keys with trading permission only and withdrawals disabled: even in the worst case, a leaked key cannot move funds out of your account.
Nothing. The bot is free and open-source under the MIT License — no subscription, no profit share, no license tier. Your only costs are the exchange's normal trading fees and whatever you pay for a server, if you use one.
HTX is the supported exchange today, trading USDT-M perpetual futures. The bot is built on a hybrid transport: CCXT handles public market data while a native HTX v5 client handles the private account and order surface used by current HTX accounts. Exchange transport is engine-owned, so adding another venue does not require rewriting each strategy.
No. Version 1.3 selects a strategy package by name, without changing the engine. The default is BTC Countertrend Grid; an isolated EMA Pullback adapter is included, and third-party packages can register through a standard entry point. Engine-owned execution safety, state, exchange transport, and telemetry remain in place when the strategy changes.
Exchange bot constructors offer a handful of templates (grid, DCA) with a few sliders. CROT separates a reusable execution engine from versioned strategy plugins, keeps analytical telemetry in SQLite, exposes validated strategy schemas, and ships offline conformance tests and research tools. Because the code is open, every order path and safety rule can be inspected.
Yes. The project ships engine, strategy, analysis, and strategy-agnostic conformance tests that run against mocks and stubs without placing live orders. Passing them proves repository integrity, not profitability or live readiness; permissions, account mode, risk tiers, open positions, and exchange-side protection still require a separate check.
Full disclosure: the HTX and MEXC links on this page carry a referral code. If you register through them, the project receives a commission from the exchange at no extra cost to you — it is the only monetization this free project has. You are, of course, free to register directly instead.
Everything described on this page is verifiable in the repository — the strategy document, the configuration reference, the test suite, and the full commit history. Start there.