Crypto Trading BOTS

[El Bringy]

Hello!

Yesterday I got endorsed into cryptocurrencies and how I can benefit from it while asleep.

Developed a safe-to-use crypto-bot that should buy at a lower price than the market price and sell at a slightly higher price than the entry price (to ensure at least 0.2% rise after moving down) this bot is supposed to work as high-frequency trading bot it will connect with Binance, using limit_orders to make stopLoss and profit margins.

if anybody would like to share some info about Python crypto bots would be nice since I'm trying to finalize the bot as 100% safe to use adaptable to market as it uses machine learning to understand the market historical (OHCV) data & trends, which allows the code to predict the price of the following second and either to buy or not, the code re-trains itself on latest data to give the best input features for the LTSM model training.

I think I implemented enough techniques including market bands & RSI but it feels like something is missing, like for example if the code didn't make a purchase but it thinks it did but binance failed it will sell as it made a past purchase, anybody is doing the same with python or have idea how to make that code work seamlessly?

any instruction or tips into making this bot safe to use on spot account with 500+USD like safety measurements OR technique & logic required im sure im missing alot, i also don't mind sharing the whole code didn't feel like discussion is the good place for it.

 

[Tenzhiro]

Hello!

Yesterday I got endorsed into cryptocurrencies and how I can benefit from it while asleep.

Developed a safe-to-use crypto-bot that should buy at a lower price than the market price and sell at a slightly higher price than the entry price (to ensure at least 0.2% rise after moving down) this bot is supposed to work as high-frequency trading bot it will connect with Binance, using limit_orders to make stopLoss and profit margins.

if anybody would like to share some info about Python crypto bots would be nice since I'm trying to finalize the bot as 100% safe to use adaptable to market as it uses machine learning to understand the market historical (OHCV) data & trends, which allows the code to predict the price of the following second and either to buy or not, the code re-trains itself on latest data to give the best input features for the LTSM model training.

I think I implemented enough techniques including market bands & RSI but it feels like something is missing, like for example if the code didn't make a purchase but it thinks it did but binance failed it will sell as it made a past purchase, anybody is doing the same with python or have idea how to make that code work seamlessly?

(Sorry OCD)

 

[El Bringy]

Hello!

Yesterday I got endorsed into cryptocurrencies and how I can benefit from it while asleep.

Developed a safe-to-use crypto-bot that should buy at a lower price than the market price and sell at a slightly higher price than the entry price (to ensure at least 0.2% rise after moving down) this bot is supposed to work as high-frequency trading bot it will connect with Binance, using limit_orders to make stopLoss and profit margins.

if anybody would like to share some info about Python crypto bots would be nice since I'm trying to finalize the bot as 100% safe to use adaptable to market as it uses machine learning to understand the market historical (OHCV) data & trends, which allows the code to predict the price of the following second and either to buy or not, the code re-trains itself on latest data to give the best input features for the LTSM model training.

I think I implemented enough techniques including market bands & RSI but it feels like something is missing, like for example if the code didn't make a purchase but it thinks it did but binance failed it will sell as it made a past purchase, anybody is doing the same with python or have idea how to make that code work seamlessly?

(Sorry OCD)

Edited main post thanks :'D

 

[Monacomer]

I’ve been messing with a few self-made bots using simple strategies like RSI or MACD, but they need constant tweaking since market conditions shift fast and unexpected stuff can break everything.

 

[El Bringy]

I’ve been messing with a few self-made bots using simple strategies like RSI or MACD, but they need constant tweaking since market conditions shift fast and unexpected stuff can break everything.

Instead tweaking it myself i just let LTSM model (machine learning) study historical data and improve the signatures for each indicator to define the best entry position to catch the desired return of revenue %, since crypto is very volatile i also use high frequency trading for 0.5% more than the trading fee to make 100+ trade per hour succes rate used to be 90% last time i tried which is supposed to be huge, im still improving it to have a web application to monitor logs, execute & stop trading and better management.

Better use LTSM highest priority on the last 1 year and 1 month and general input on the whole historical data available, for binance you can use ccxt library (python)

It's easy to use class weights with TensorFlow for this purpose. See the class_weight parameter for model.fit(): (source : stackoverflow)

https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit

 

[Monacomer]

I’ve been messing with a few self-made bots using simple strategies like RSI or MACD, but they need constant tweaking since market conditions shift fast and unexpected stuff can break everything.

I messed around with a few bots last winter, and most of them were either too basic or too risky without much control. Ended up checking out https://quantumaiofficial.com/ after a buddy mentioned it, and it's been decent so far—super simple to set up, and the settings give you enough control without needing to be a pro. Still testing it, but no major complaints yet.

 

[cinaraot]

I messed around with a few bots last winter, and most of them were either too basic or too risky without much control. Ended up checking out https://quantumaiofficial.com/ after a buddy mentioned it, and it's been decent so far—super simple to set up, and the settings give you enough control without needing to be a pro. Still testing it, but no major complaints yet.

I dont think this is safe. I cant find anything about it on the internet.

 

[El Bringy]

I dont think this is safe. I cant find anything about it on the internet.

Trading bots have so many fraud so its right to be cautious and create your own bot

 

[Delonasby]

I tried using one on a test account with small amounts, and it followed trends okay, but sudden market drops still messed it up. You gotta watch it regularly.

 

[Marko999x]

I tried using one on a test account with small amounts, and it followed trends okay, but sudden market drops still messed it up. You gotta watch it regularly.

ok

 

[Delonasby]

I’ve tried a few bots before, but most were either too complex or needed constant tweaking. Currently testing elonmuskaitrading.com and it’s been surprisingly simple to set up. I don’t need to babysit it all day, and it gives me decent control without overwhelming me with settings. Still monitoring results, but so far it’s doing better than my manual trades.

 

[El Bringy]

I’ve tried a few bots before, but most were either too complex or needed constant tweaking. Currently testing elonmuskaitrading.com and it’s been surprisingly simple to set up. I don’t need to babysit it all day, and it gives me decent control without overwhelming me with settings. Still monitoring results, but so far it’s doing better than my manual trades.

I suppose thats not a coded trading bot but a service with GUI right?

 

[Obito]

Hello!

Yesterday I got endorsed into cryptocurrencies and how I can benefit from it while asleep.

Developed a safe-to-use crypto-bot that should buy at a lower price than the market price and sell at a slightly higher price than the entry price (to ensure at least 0.2% rise after moving down) this bot is supposed to work as high-frequency trading bot it will connect with Binance, using limit_orders to make stopLoss and profit margins.

if anybody would like to share some info about Python crypto bots would be nice since I'm trying to finalize the bot as 100% safe to use adaptable to market as it uses machine learning to understand the market historical (OHCV) data & trends, which allows the code to predict the price of the following second and either to buy or not, the code re-trains itself on latest data to give the best input features for the LTSM model training.

I think I implemented enough techniques including market bands & RSI but it feels like something is missing, like for example if the code didn't make a purchase but it thinks it did but binance failed it will sell as it made a past purchase, anybody is doing the same with python or have idea how to make that code work seamlessly?

any instruction or tips into making this bot safe to use on spot account with 500+USD like safety measurements OR technique & logic required im sure im missing alot, i also don't mind sharing the whole code didn't feel like discussion is the good place for it.

 

[El Bringy]

Far easier way to fetch pairs historial data is this is example for 1h timeframe limited on 200 hours fetching you can go for lifetime pair historical data as well.

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = 'BTC/USDT'
timeframe = '1h'
limit = 200

ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')

print(df.head())

you can also pass LTSM Model (machine learning over it with some technical analysis used in crypto to define your best entry position and sell position by percentage of revenue it suppose based on historical data, if its less than fee it shouldn't buy anyway based on your choice of the bot type, high frequency or slow, 1 trade per time or multiple, limited to USDT Spent/lost and trade amounts or not.

example of applying ltsm model on historical data from ccxt library like this

import ccxt
import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

exchange = ccxt.binance()
symbol = 'BTC/USDT'
timeframe = '1h'
limit = 500

ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
df = pd.DataFrame(ohlcv, columns=['timestamp','open','high','low','close','volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')

scaler = MinMaxScaler(feature_range=(0,1))
scaled = scaler.fit_transform(df[['close']].values)

lookback = 60
X, y = [], []
for i in range(lookback, len(scaled)):
    X.append(scaled[i-lookback:i, 0])
    y.append(scaled[i, 0])
X, y = np.array(X), np.array(y)
X = np.reshape(X, (X.shape[0], X.shape[1], 1))

model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(X.shape[1],1)))
model.add(Dropout(0.2))
model.add(LSTM(50))
model.add(Dropout(0.2))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')
model.fit(X, y, epochs=20, batch_size=32, verbose=0)

last_sequence = scaled[-lookback:]
last_sequence = np.reshape(last_sequence, (1, lookback, 1))
predicted = model.predict(last_sequence)
predicted_price = scaler.inverse_transform(predicted)[0][0]

current_price = df['close'].iloc[-1]
fee_rate = 0.001  # 0.1% typical Binance spot trading fee
expected_gain = (predicted_price - current_price) / current_price

if expected_gain > fee_rate:
    print("Buy signal: predicted price =", predicted_price, "current =", current_price)
elif expected_gain < -fee_rate:
    print("Sell signal: predicted price =", predicted_price, "current =", current_price)
else:
    print("No trade: expected gain less than fee.")

i actually built a whole trading bots based on this theory i was excited to discuss it here with other devs but nobody seem doing trading bots nowdays

 

[Obito]

Hello!

Yesterday I got endorsed into cryptocurrencies and how I can benefit from it while asleep.

Developed a safe-to-use crypto-bot that should buy at a lower price than the market price and sell at a slightly higher price than the entry price (to ensure at least 0.2% rise after moving down) this bot is supposed to work as high-frequency trading bot it will connect with Binance, using limit_orders to make stopLoss and profit margins.

if anybody would like to share some info about Python crypto bots would be nice since I'm trying to finalize the bot as 100% safe to use adaptable to market as it uses machine learning to understand the market historical (OHCV) data & trends, which allows the code to predict the price of the following second and either to buy or not, the code re-trains itself on latest data to give the best input features for the LTSM model training.

I think I implemented enough techniques including market bands & RSI but it feels like something is missing, like for example if the code didn't make a purchase but it thinks it did but binance failed it will sell as it made a past purchase, anybody is doing the same with python or have idea how to make that code work seamlessly?

any instruction or tips into making this bot safe to use on spot account with 500+USD like safety measurements OR technique & logic required im sure im missing alot, i also don't mind sharing the whole code didn't feel like discussion is the good place for it.

Tbh, you can use technical analysis with SMC/liquidity techniques that makes it safer.. (I was actually working on this with someone who was studying ML and had a deep understanding of it) , consider also using Python libraries like TA-Lib to make reading market history easier Personally, I prefer trading safer pairs like DXY and XAUUSD not only crypto

 

[El Bringy]

Tbh, you can use technical analysis with SMC/liquidity techniques that makes it safer.. (I was actually working on this with someone who was studying ML and had a deep understanding of it) , consider also using Python libraries like TA-Lib to make reading market history easier Personally, I prefer trading safer pairs like DXY and XAUUSD not only crypto

I have a code that includes all of this even higher level techniques i can share its features information but not the code unforunately it is used in business:

CHATGPT RESPONSE

---

Got it You want a full technical documentation of your trading bot – including every technical analysis type, machine learning feature, and programming features it has. I’ll break this into sections so you can see everything clearly.​

---

🏗​

• Class-Based Design
  • Encapsulation of all trading logic in class BinanceBot.
  • Initialization parameters:
    • api_key, api_secret → Binance API credentials
    • profit_margin → Target profit percentage per trade
    • max_loss_margin → Maximum acceptable loss (stop loss)
    • price_check_interval → Delay between trading loop cycles
    • timeframe, limit → OHLCV historical data window size
• Persistent State
  • self.trades → Active trades in progress
  • self.trade_history → Closed trade outcomes (used for win rate, Sharpe ratio, etc.)
• Error Handling & Safety
  • Extensive try/except blocks around Binance API calls.
  • Fallbacks for rounding, precision, and feature calculation.
  • Warnings if orders fall below Binance minimums.
• Trade Size Calculation
  • calculate_position_size_xrp() → Uses XRP balance or fixed trade amount.
  • calculate_position_size() → Dynamically sizes positions based on volatility (ATR-based).
  • Enforces Binance minimum notional rules (min_cost, min_amount).
• Rounding & Precision
  • round_step_size() aligns order sizes with Binance tick sizes.
  • Prevents rejected orders from precision mismatch.
• Performance Metrics
  • Tracks:
    • win_rate
    • avg_profit
    • max_drawdown
    • sharpe_ratio

---

​

Your bot integrates multiple indicators & conditions for entries and exits:

1. RSI (Relative Strength Index)
   • rsi_oversold = 30
   • rsi_overbought = 70
   • Identifies overbought/oversold conditions.
2. MACD (Moving Average Convergence Divergence)
   • Used in feature engineering and ML inputs.
   • Detects momentum shifts.
3. ATR (Average True Range)
   • Used in volatility-based position sizing.
   • Determines how much balance to risk.
4. Momentum & Volume Filters
   • momentum_threshold = 0.001 → Ignore weak moves.
   • volume_threshold = 1.5 → Requires strong volume before entry.
5. Trailing Stop-Loss
   • trailing_stop_pct = 0.01 → 1% trailing stop from peak.
   • Locks in profits while allowing trend continuation.
6. Max Trade Duration
   • max_trade_duration = 3600 (1 hour).
   • Forces exit if trade lingers too long.

---

​

You integrated an ensemble ML system:

1. Feature Engineering
   • Generates lagged values of close, volume, rsi, macd.
   • Uses shift() to capture historical dependencies.
   • Target: 1 if price increases after 12 periods, else 0.
2. Scaling
   • StandardScaler() standardizes features before training.
3. ML Models
   • RandomForestClassifier (ensemble tree model).
   • XGBoost (gradient boosting model).
   • Both stored in self.ensemble_models.
4. Ensemble Prediction
   • predict_with_ensemble() averages probability outputs.
   • Returns bullish probability score [0,1].
5. LSTM Support (Planned)
   • self.sequence_length = 50
   • self.n_features set dynamically
   • Would allow sequential deep learning with price time-series.
6. ML + Technical Confirmation
   • Only enters if both technical signals and ML agree.
   • Example: RSI says "oversold" but ML says downtrend → no trade.

---

🛠​

• Entry Conditions
  • Checks technical signals (RSI, MACD, volume, etc.).
  • ML ensemble validates signals.
  • Requires expected profit > exchange fee.
• Exit Conditions
  • Profit target reached (profit_margin).
  • Stop-loss triggered (max_loss_margin).
  • Trailing stop activated.
  • Trade exceeds max duration (forced close).
• Fee Awareness
  • Skips trades if expected profit < Binance trading fee (0.1% default).
• Concurrency Control
  • Maximum concurrent trades = trade_limit.
  • Ensures no over-exposure.

---

​

• Fetches:
  • OHLCV candles (fetch_ohlcv).
  • Tickers (fetch_ticker).
  • Balances (fetch_balance).
  • Market minimums (load_markets).
• Places:
  • Market orders (place_market_order).
  • Auto-adjusted to Binance tick sizes.

---

🖥​

• CLI arguments via argparse:
  • --pair (XRP/USDT default).
  • --trade_amount (fixed in USDT, or adaptive).
  • --count (max trades).
  • --profit_margin (target, e.g., 1%).
  • --loss_margin (stop-loss, e.g., 1%).
  • --interval (price check interval in seconds).

---

​

This bot is a hybrid ML + TA trading system with:

• Full Binance integration
• Technical indicators (RSI, MACD, ATR, volume, momentum)
• Machine Learning (Random Forest + XGBoost, LSTM-ready)
• Smart position sizing (balance-based, volatility-based, or fixed)
• Trailing stop-loss, profit targets, stop-loss protection
• Fee awareness (skips trades below profitability threshold)
• Trade concurrency limit + performance tracking
• Command-line control + API error handling

---

It’s basically an intelligent ensemble bot that blends technical analysis + ML + strict Binance compliance.

Thats exactly what GPT said when i asked it to summarize my bot, its 9 months ago created.

And this is the algorithm behaviour tree and psuedocode:

Entry Decision Tree (Buy)​

1. Data ready?
   • Have at least limit candles and all features (RSI, MACD, volume stats, ATR, lags) computed?
   • If no → skip this tick.
2. Baseline market filters
   • Latest close price is valid (not NaN, nonzero).
   • Spread / slippage acceptable (if you check it).
   • If no → skip.
3. Momentum + Volume confirmation
   • Compute returns ret_1 = close[t]/close[t-1] - 1.
   • Momentum gate: ret_1 ≥ momentum_threshold (default 0.001 = 0.1%).
   • Volume gate: volume_zscore ≥ volume_threshold (default 1.5).
   • If either fails → no strong entry (continue but likely skip unless ML is very strong).
4. RSI regime
   • RSI ≤ rsi_oversold (30) → bullish regime (good for buy candidates).
   • RSI ≥ rsi_overbought (70) → avoid buys (or wait for pullback).
   • Middle RSI → neutral; rely more on MACD/ML.
5. MACD confirmation
   • Bullish if MACD &gt; 0 and MACD - Signal &gt; 0 (histogram positive or turning positive).
   • Divergence turning up counts as weak bullish.
6. Ensemble ML veto/confirm
   • Build feature vector from last row (including lags) → p_up = ensemble_predict_proba()
   • If p_up &lt; 0.40 → veto: don’t enter even if TA is good.
   • If 0.40 ≤ p_up &lt; 0.55 → neutral; need strong TA to proceed.
   • If p_up ≥ 0.55 → confirm; can proceed with weaker TA if fees are covered.
7. Profit vs. Fee check (crucial)
   • Get current price P0 and your expected exitprice P*.
     • If you use the simple one-step forecast: P* = predicted_next_close (or TA target such as P0 * (1 + profit_margin) if you don’t forecast).
   • Expected gross gain: (P* - P0) / P0.
   • Round-trip fee (spot): fee ≈ 2 * taker_fee (e.g., 2 * 0.001 = 0.002 = 0.2%) unless you’re maker or have VIP.
   • Require: Expected gain ≥ fee + safety_buffer (e.g., +0.05% extra).
   • If no → skip the trade.
8. Min notional & precision
   • Calculate quantity by rule (fixed USDT or adaptive).
   • Enforce min_cost and min_amount via round_step_size() and exchange limits.
   • If order value &lt; min_notional → scale up (or skip if you refuse scaling).
9. Concurrency & duplicates
   • len(trades) &lt; trade_limit?
   • No overlapping position on the same symbol (or allow pyramids per rules)?
   • If OK → Enter BUY (market order).
10. Set safeguards immediately on entry

• Take Profit: TP = entry_price * (1 + profit_margin)
• Stop Loss: SL = entry_price * (1 - max_loss_margin)
• Trailing Stop anchor: trail = entry_price * (1 - trailing_stop_pct)
• Max duration: entry_time = now, enforce max_trade_duration.

---

Exit Decision Tree (Manage Open Trade)​

For each open trade on every tick:

1. Update live PnL
   • u = (price_now / entry_price) - 1.
2. Hard stop-loss
   • If price_now ≤ SL → Sell (market). Record loss.
3. Take-profit
   • If price_now ≥ TP → Sell (market). Record win.
4. Trailing stop
   • If price_now &gt; highest_price_since_entry, update trail = max(trail, price_now * (1 - trailing_stop_pct)).
   • If price_now ≤ trail → Sell (lock gains).
5. Time stop
   • If now - entry_time ≥ max_trade_duration (default 3600s) → Sell (exit stale trade).
6. ML deterioration (optional rule)
   • If p_up drops well below neutral for N consecutive ticks (e.g., p_up ≤ 0.35 for 3–5 checks) → early exit to protect capital.

---

Position Sizing (in order of precedence)​

1. Fixed USDT amount provided?
   • qty = trade_amount / price_now → round to symbol amount.step.
   • Ensure qty * price_now ≥ min_notional → scale or skip.
2. XRP balance based rule(calculate_position_size_xrp)
   • Use xrp_balance * 0.10 (10%) notionally, convert to qty = notional / price.
3. Volatility-adaptive (ATR %) rule(calculate_position_size)
   • Compute atr_pct = ATR / close * 100.
   • If atr_pct &lt; 1.0 → position = 10% of USDT free.
   • If 1.0 ≤ atr_pct &lt; 2.0 → position = 5%.
   • Else → position = 2%.
   • qty = position / price_now → round to step.

Always re-check min_notional & precision after rounding.

---

Signal Aggregation & Tie-Breaks​

• Strong Buy=
  • RSI ≤ 30 AND (MACD > 0 or MACD histogram turning up) AND momentum & volume gates passed.
  • ML: p_up ≥ 0.55 (or ≥ 0.60 if RSI not oversold).
  • Fees covered by expected gain.
• Neutral/Wait=
  • Mixed RSI (30–70) or weak MACD or low volume.
  • ML between 0.40–0.55 → require fees + stronger TA (e.g., add higher momentum or bullish candle patterns).
• Veto=
  • ML p_up &lt; 0.40 → do not enter even if TA is good.
  • Or fee coverage fails.

If signals disagree:

• ML < 0.40 always wins (no entry).
• If ML ≥ 0.65 you may relax TA slightly (e.g., accept RSI=35–40 if MACD just crossed up).
• When in doubt, require both: fees covered + at least 2 TA positives (e.g., RSI regime + MACD).

---

Compact Pseudocode​

on_tick(symbol):
  data = fetch_ohlcv(symbol)
  feats = enhanced_feature_engineering(data)
  row = feats.last_row()

  if not row or has_nan(row): return

  P0 = row.close
  rsi = row.rsi
  macd = row.macd
  macd_sig = row.macd_signal
  hist = macd - macd_sig
  ret1 = P0/prev_close - 1
  vol_z = row.volume_zscore
  atr_pct = row.atr / P0 * 100

  momentum_ok = (ret1 >= momentum_threshold)
  volume_ok   = (vol_z >= volume_threshold)
  rsi_bull    = (rsi <= 30)
  macd_bull   = (macd > 0 and hist >= 0) or turning_up(hist)

  p_up = ensemble_predict_proba(row)  # None if models missing
  if p_up is not None and p_up < 0.40: allow_entry = False
  else:
      allow_entry = (momentum_ok and volume_ok and (rsi_bull or macd_bull))

  if allow_entry:
      Pstar = expected_exit_price(row, P0, profit_margin, p_up)  # e.g., model forecast or P0*(1+profit_margin)
      exp_gain = (Pstar - P0)/P0
      roundtrip_fee = 2 * taker_fee  # or maker+taker

      if exp_gain >= roundtrip_fee + buffer:
          qty = position_size(symbol, P0, trade_amount, atr_pct)
          if qty and qty*P0 >= min_notional and slots_available():
              order = place_market_buy(symbol, qty)
              register_trade(order, TP=P0*(1+profit_margin), SL=P0*(1-max_loss_margin),
                             trail=P0*(1-trailing_stop_pct), start_time=now)

Open trade management runs every tick to enforce SL, TP, trailing, and time stop.

---

Practical Thresholds (good starting points)​

• momentum_threshold: 0.001 (0.1%)
• volume_threshold: 1.5 z-score
• rsi_oversold: 30, rsi_overbought: 70
• trailing_stop_pct: 0.01 (1%)
• profit_margin: 0.5–1.0% intraday; higher for longer frames
• max_loss_margin: 0.5–1.0% (match your TP:SL plan)
• ML veto: p_up &lt; 0.40; confirm ≥ 0.55
• Round-trip fee: assume 0.20–0.30% unless you know your exact maker/taker

---

Edge Cases & Safety​

• NaNs / short history: skip decisions until all features valid.
• Precision errors: always run round_step_size() and re-validate min_notional.
• API hiccups: on exceptions, sleep price_check_interval and retry.
• Duplicate entries: don’t open a second trade on same symbol unless you explicitly allow pyramiding.
• Flash spikes: if ATR explodes mid-trade, keep trailing stop tight; don’t widen SL.
• Fee drift: if you change from taker to maker, update fee model (don’t under-estimate).

My whole point is ML + guidance by something like technical analysis always gives insane success rate results

 

[Casualeren]

I played around with a few bots using basic strategies like RSI and moving averages. They can work short-term, but I still lost during big swings. Manual tweaks help a lot.

 

[Casualeren]

I've played around with a few bots and noticed most of them either need a lot of manual tweaking or just blindly follow indicators. If you're more into funded accounts or testing strategies without much risk, I found some helpful info at Reviews for broker (https://tradelytic.com/prop-firms/reviews/traderscale/) — broke down their rules and profit targets in a clear way, which helped me decide if it was worth giving it a shot.

 

[Byr]

Honestly, the biggest challenge usually isn’t the prediction model itself, it’s trade execution reliability and risk management. A lot of bots look amazing in backtests but break in live trading because of latency, partial fills, API failures, spread/slippage, or state desync issues exactly like the one you described where the bot “thinks” it owns a position when the order never actually filled.

One thing that helps is treating Binance as the source of truth at all times instead of your local variables. After every buy/sell request, query the actual order status and wallet balance before updating internal state. Also build safeguards like max daily loss, cooldown periods after failed orders, duplicate-order prevention, and emergency stop conditions if API responses become inconsistent.

And honestly, be careful with the “predict the next second” mindset. Crypto markets are noisy enough that many ML models end up overfitting historical OHCV data without surviving real market conditions. Sometimes simpler logic with strong execution and strict risk control outperforms more advanced prediction systems long term. Starting with small spot amounts and paper trading for weeks before scaling is definitely the safest route.

 

[JeiDi]

Any stats or data from actual real-world runs?