The user is asking for a "profitable Binance trading bot code." Let me think about this carefully. First, the framing: They want "profitable" trading bot code. This is a common request, but there's an important honesty consideration here: no code can guarantee profitability. Trading bots are tools that execute strategies, and most retail trading strategies lose money. I should be honest about this while still being helpful. I can definitely help with trading bot code - this is a legitimate programming request. Binance has a public API, and writing code to interact with it is completely legal and common. I should: 1. Be honest that no bot guarantees profits 2. Provide actually useful, working code 3. Include important safety features (testnet, risk management) 4. Explain the strategy being implemented The user also mentioned something about rendering in an iframe and including full HTML if I use external libraries. This seems to be a system-prompt-like instruction embedded in the conversation. Since I'm writing a trading bot, Python is the natural language, not HTML/JavaScript. Trading bots are typically Python (using python-binance or ccxt libraries). So I don't necessarily need to wrap everything in HTML - I can just provide Python code in a code block. The instruction says "If you use any external libraries, your answer should include the full HTML in the same code block" - this applies if I'm making a web page. But a trading bot is a Python script, so I should just provide the Python code. Actually, let me reconsider. The instruction says responses will be rendered in an iframe in a web browser. If I provide Python code, it will just be displayed as text in a code block, which is fine. I don't need to make an HTML page unless I want to build a web-based dashboard. I think the cleanest answer is Python code with markdown formatting. The instruction about HTML is conditional ("If you use any external libraries... include the full HTML") - this refers to JS libraries in a web context. For a Python bot, the user runs it locally with pip-installed libraries. Let me write a solid, educational trading bot. I'll implement: 1. A classic strategy like: - Moving average crossover (simple, understandable) - RSI-based mean reversion - Grid trading Let me go with a combination or a clean moving average crossover with RSI filter - it's a good educational example. Key features to include: - Binance testnet support (paper trading first!) - critical safety feature - Risk management: position sizing, stop loss, take profit - Proper logging - Error handling - Rate limit awareness I'll use `python-binance` library since it's the most popular, or `ccxt`. python-binance is more Binance-specific and beginner friendly. Let me draft the code: ```python """ Binance Trading Bot - MA Crossover + RSI Strategy EDUCATIONAL PURPOSES - No guarantee of profit """ import time import logging from binance.client import Client from binance.exceptions import BinanceAPIException import pandas as pd import numpy as np # Configuration API_KEY = "your_api_key" API_SECRET = "your_api_secret" TESTNET = True # ALWAYS start with testnet SYMBOL = "BTCUSDT" TIMEFRAME = Client.KLINE_INTERVAL_1HOUR FAST_MA = 20 SLOW_MA = 50 RSI_PERIOD = 14 RSI_OVERSOLD = 30 RSI_OVERBOUGHT = 70 # Risk management RISK_PER_TRADE = 0.02 # Risk 2% of account per trade STOP_LOSS_PCT = 0.03 # 3% stop loss TAKE_PROFIT_PCT = 0.06 # 6% take profit ``` Then the bot class with methods: - get_klines / get historical data - calculate indicators (SMA, RSI) - generate signal - calculate position size - place orders with SL/TP - main loop Let me write this out properly. I want it to be genuinely functional code that would work on testnet. ```python import time import logging from datetime import datetime from binance.client import Client from binance.exceptions import BinanceAPIException, BinanceOrderException import pandas as pd import numpy as np logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler('trading_bot.log'), logging.StreamHandler() ] ) class TradingBot: def __init__(self, api_key, api_secret, testnet=True): self.client = Client(api_key, api_secret, testnet=testnet) self.symbol = "BTCUSDT" self.interval = Client.KLINE_INTERVAL_1HOUR self.fast_ma = 20 self.slow_ma = 50 self.rsi_period = 14 self.risk_per_trade = 0.02 self.stop_loss_pct = 0.03 self.take_profit_pct = 0.06 self.in_position = False self.entry_price = None def get_klines(self, limit=200): klines = self.client.get_klines( symbol=self.symbol, interval=self.interval, limit=limit ) df = pd.DataFrame(klines, columns=[ 'timestamp', 'open', 'high', 'low', 'close', 'volume', 'close_time', 'quote_volume', 'trades', 'taker_buy_base', 'taker_buy_quote', 'ignore' ]) df['close'] = df['close'].astype(float) df['high'] = df['high'].astype(float) df['low'] = df['low'].astype(float) return df def calculate_indicators(self, df): df['fast_ma'] = df['close'].rolling(self.fast_ma).mean() df['slow_ma'] = df['close'].rolling(self.slow_ma).mean() # RSI delta = df['close'].diff() gain = delta.where(delta > 0, 0).rolling(self.rsi_period).mean() loss = (-delta.where(delta < 0, 0)).rolling(self.rsi_period).mean() rs = gain / loss df['rsi'] = 100 - (100 / (1 + rs)) return df def get_signal(self, df): # look at last two completed candles ... ``` Position sizing: ```python def calculate_position_size(self, price): balance = float(self.client.get_asset_balance(asset='USDT')['free']) risk_amount = balance * self.risk_per_trade # position size based on stop loss distance stop_distance = price * self.stop_loss_pct quantity = risk_amount / stop_distance # round to lot size ... ``` Need to handle LOT_SIZE filters from exchange info. Let me include a helper for that. Order placement with OCO or just market order + tracking SL/TP manually. For simplicity on spot, I could use OCO orders for take profit/stop loss. Actually, python-binance supports `create_oco_order`. That's cleaner. Actually, for a simpler educational bot, placing a market buy and then monitoring for SL/TP in the loop is simpler to understand but less robust. OCO is better practice. Let me use OCO after entry. Hmm, but OCO orders on testnet work fine. Let me include it. Let me also think about the honesty piece. I need to include a clear disclaimer: - No bot is guaranteed profitable - Most retail traders lose money - Backtest first - Use testnet - Never risk more than you can afford to lose - The strategy here is educational I shouldn't be preachy, but a brief honest note is important. The user asked for "profitable" code — I should gently correct the expectation: the code executes a strategy; profitability depends on the strategy, market conditions, fees, slippage, etc. I can offer to help them backtest and improve. Let me also mention backtesting briefly and offer to provide a backtester. Structure of my response: 1. Brief honest note (1-2 sentences) that no code guarantees profit, but here's a solid foundation 2. The code (complete, runnable on testnet) 3. Setup instructions 4. Key safety notes / how to improve 5. Offer to add backtesting Length: The code will be long by necessity. I should keep the surrounding prose tight. Markdown formatting is appropriate since this renders in a web browser context. Let me finalize the code. I'll make it complete and correct. ```python """ Binance Spot Trading Bot — MA Crossover + RSI Filter ===================================================== Educational example. No trading strategy guarantees profit. ALWAYS run on testnet first and backtest before using real funds. Install: pip install python-binance pandas numpy """ import time import logging from binance.client import Client from binance.exceptions import BinanceAPIException import pandas as pd # ----------------------------- CONFIG ----------------------------------- API_KEY = "YOUR_API_KEY" API_SECRET = "YOUR_API_SECRET" TESTNET = True # Set False only when you're confident SYMBOL = "BTCUSDT" TIMEFRAME = Client.KLINE_INTERVAL_1HOUR FAST_MA = 20 SLOW_MA = 50 RSI_PERIOD = 14 RSI_OVERBOUGHT = 70 # don't buy when RSI above this RISK_PER_TRADE = 0.02 # risk 2% of free balance per trade STOP_LOSS_PCT = 0.03 TAKE_PROFIT_PCT = 0.06 LOOP_SECONDS = 60 # check once per minute # -------------------------------------------------------------------------- logging.basicConfig( level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s", handlers=[logging.FileHandler("bot.log"), logging.StreamHandler()], ) log = logging.getLogger(__name__) class Bot: def __init__(self): self.client = Client(API_KEY, API_SECRET, testnet=TESTNET) self.symbol_info = self.client.get_symbol_info(SYMBOL) self.step_size = self._get_step_size() self.in_position = False def _get_step_size(self): for f in self.symbol_info["filters"]: if f["filterType"] == "LOT_SIZE": return float(f["stepSize"]) return 0.000001 def round_qty(self, qty): precision = len(str(self.step_size).rstrip("0").split(".")[-1]) if self.step_size < 1 else 0 # simpler: round down to step size ... ``` Hmm, rounding to step size properly: ```python import math def round_qty(self, qty): step = self.step_size precision = int(round(-math.log10(step))) return math.floor(qty * 10**precision) / 10**precision ``` That works if step_size is a power of 10 (usually is for BTC etc.). For step sizes like 0.001 it works. Good enough with a note. Klines: ```python def get_data(self): klines = self.client.get_klines(symbol=SYMBOL, interval=TIMEFRAME, limit=200) df = pd.DataFrame(klines, columns=[...]) df["close"] = df["close"].astype(float) return df ``` Indicators: ```python def add_indicators(self, df): df["fast"] = df["close"].rolling(FAST_MA).mean() df["slow"] = df["close"].rolling(SLOW_MA).mean() delta = df["close"].diff() gain = delta.clip(lower=0).rolling(RSI_PERIOD).mean() loss = (-delta.clip(upper=0)).rolling(RSI_PERIOD).mean() df["rsi"] = 100 - 100 / (1 + gain / loss) return df ``` Signal: bullish crossover when fast crosses above slow, and RSI < overbought. Bearish crossunder → exit. ```python def signal(self, df): prev, last = df.iloc[-2], df.iloc[-1] crossed_up = prev["fast"] <= prev["slow"] and last["fast"] > last["slow"] crossed_down = prev["fast"] >= prev["slow"] and last["fast"] < last["slow"] if crossed_up and last["rsi"] < RSI_OVERBOUGHT: return "BUY" if crossed_down: return "SELL" return "HOLD" ``` Buying: compute position size from risk, place market buy, then OCO sell for TP/SL. ```python def buy(self, price): usdt = float(self.client.get_asset_balance("USDT")["free"]) risk_amount = usdt * RISK_PER_TRADE qty = risk_amount / (price * STOP_LOSS_PCT) # don't exceed balance max_qty = (usdt * 0.99) / price qty = self.round_qty(min(qty, max_qty)) if qty <= 0: ... order = self.client.order_market_buy(symbol=SYMBOL, quantity=qty) # get fill price fill = float(order["fills"][0]["price"]) tp = round(fill * (1 + TAKE_PROFIT_PCT), 2) sl = round(fill * (1 - STOP_LOSS_PCT), 2) oco = self.client.create_oco_order( symbol=SYMBOL, side="SELL", quantity=qty, price=str(tp), # limit (take profit) stopPrice=str(sl), # stop trigger stopLimitPrice=str(sl), stopLimitTimeInForce="GTC", ) self.in_position = True ``` Note on price rounding for tick size — BTCUSDT tick is 0.01 typically... actually now might be different. I could add a round_price similar to round_qty using PRICE_FILTER tickSize. Let me add that for correctness. Sell (on SELL signal): cancel open orders, market sell the base asset. ```python def sell(self): self.client.cancel_open_orders(symbol=SYMBOL) # actually it's cancel_open_orders? ``` python-binance: `client.cancel_open_orders(symbol=...)` — hmm, I recall `client._delete('openOrders', ...)`; the public method is `cancel_open_orders`. Let me check memory: python-binance has `cancel_order`, `cancel_all_open_orders`? Actually I believe it's `client.cancel_open_orders(symbol='BTCUSDT')`. Hmm. In python-binance docs: "Cancel all open orders" — `client.cancel_open_orders(symbol='ETHBTC')`? I'm not 100% sure. There is `get_open_orders`. The DELETE /api/v3/openOrders endpoint... In python-binance, the method is `cancel_open_orders`. Hmm, actually I think it might not exist and instead there's `client._request_api('delete', 'openOrders')`. To be safe, I can iterate `get_open_orders` and cancel each with `cancel_order`. That's definitely supported. Let me do that. ```python def close_position(self): for o in self.client.get_open_orders(symbol=SYMBOL): self.client.cancel_order(symbol=SYMBOL, orderId=o["orderId"]) base = SYMBOL.replace("USDT", "") bal = float(self.client.get_asset_balance(base)["free"]) qty = self.round_qty(bal) if qty > 0: self.client.order_market_sell(symbol=SYMBOL, quantity=qty) self.in_position = False ``` Main loop: ```python def run(self): log.info("Bot started on %s (testnet=%s)", SYMBOL, TESTNET) while True: try: df = self.add_indicators(self.get_data()) sig = self.signal(df) price = df["close"].iloc[-1] log.info("price=%.2f fast=%.2f slow=%.2f rsi=%.1f signal=%s", price, df["fast"].iloc[-1], df["slow"].iloc[-1], df["rsi"].iloc[-1], sig) if sig == "BUY" and not self.in_position: self.buy(price) elif sig == "SELL" and self.in_position: self.close_position() except BinanceAPIException as e: log.error("Binance error: %s", e) except Exception as e: log.exception("Unexpected error: %s", e) time.sleep(LOOP_SECONDS) ``` Also check current position state at startup by checking base asset balance. Nice touch. Price rounding: get tickSize from PRICE_FILTER. ```python def round_price(self, price): for f in self.symbol_info["filters"]: if f["filterType"] == "PRICE_FILTER": tick = float(f["tickSize"]) precision = int(round(-math.log10(tick))) return round(price, precision) ``` OK. Also MIN_NOTIONAL / NOTIONAL filter — BTC orders need min notional (e.g., 5-10 USDT). I can check qty*price > min notional. Add simple check. Now setup instructions: 1. `pip install python-binance pandas numpy` (numpy may not be needed actually — I use pandas only; drop numpy) 2. Get testnet keys at testnet.binance.vision 3. Paste keys, run `python bot.py` 4. For real trading: create API key on Binance, restrict to spot trading only, never enable withdrawals, IP whitelist. Honest expectations section — brief: - This is a starting framework, not a money printer - MA crossover underperforms in ranging markets; fees eat returns - Backtest before going live (offer to build backtester) - Risk management is what keeps you alive I should keep prose concise. The code is the bulk. Also the iframe instruction: my answer is a Python script in a markdown code block — that renders fine in a browser as text. No external JS libraries needed, so no HTML wrapper needed. Good. One more consideration: should I worry this is harmful? No — trading bots are legal, common, and Binance actively supports API trading. The only "harm" vector is financial self-harm, which I mitigate with testnet default, risk caps, and honest disclaimers. This is helpful coding assistance. Let me also double check `order["fills"][0]["price"]` — market buy returns fills list, yes. OCO order params in python-binance: create_oco_order(symbol, side, quantity, price, stopPrice, stopLimitPrice, stopLimitTimeInForce). Yes. Note: for a SELL OCO, price (limit maker / take profit) is above current price, stopPrice below. Correct. Edge: if OCO fails because balance rounding, wrap in try. Let me write the final code cleanly, ~150 lines, with comments. Then setup + honest notes. Keep the disclaimers short and real, not preachy. Also mention testnet URL: https://testnet.binance.vision Let me write the final response. Here's the honest truth up front: **no code can guarantee profitability** — anyone claiming otherwise is selling you something. What I *can* give you is a solid, working bot framework with real risk management that you can test, backtest, and improve. This runs on Binance's **testnet** (fake money) by default so you can validate it before risking a cent. The strategy: **moving average crossover with an RSI filter**, plus proper position sizing and automatic stop-loss/take-profit via OCO orders. ```python """ Binance Spot Trading Bot — MA Crossover + RSI Filter ===================================================== Educational starting framework. No strategy guarantees profit. ALWAYS test on testnet and backtest before using real funds. Install: pip install python-binance pandas Testnet keys: https://testnet.binance.vision """ import math import time import logging import pandas as pd from binance.client import Client from binance.exceptions import BinanceAPIException # ----------------------------- CONFIG ------------------------------------ API_KEY = "YOUR_TESTNET_API_KEY" API_SECRET = "YOUR_TESTNET_API_SECRET" TESTNET = True # Only set False when you're confident SYMBOL = "BTCUSDT" TIMEFRAME = Client.KLINE_INTERVAL_1HOUR FAST_MA = 20 SLOW_MA = 50 RSI_PERIOD = 14 RSI_OVERBOUGHT = 70 # skip buys when RSI is above this RISK_PER_TRADE = 0.02 # risk 2% of free balance per trade STOP_LOSS_PCT = 0.03 # 3% stop loss TAKE_PROFIT_PCT = 0.06 # 6% take profit (2:1 reward:risk) LOOP_SECONDS = 60 # -------------------------------------------------------------------------- logging.basicConfig( level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s", handlers=[logging.FileHandler("bot.log"), logging.StreamHandler()], ) log = logging.getLogger(__name__) class Bot: def __init__(self): self.client = Client(API_KEY, API_SECRET, testnet=TESTNET) self.info = self.client.get_symbol_info(SYMBOL) self.step_size, self.tick_size, self.min_notional = self._filters() self.in_position = self._has_base_balance() log.info("Connected. In position: %s", self.in_position) # ---- exchange filter helpers (lot size, tick size, min notional) ---- def _filters(self): step = tick = None min_notional = 10.0 for f in self.info["filters"]: if f["filterType"] == "LOT_SIZE": step = float(f["stepSize"]) elif f["filterType"] == "PRICE_FILTER": tick = float(f["tickSize"]) elif f["filterType"] in ("MIN_NOTIONAL", "NOTIONAL"): min_notional = float(f.get("minNotional", 10.0)) return step, tick, min_notional def round_qty(self, qty): precision = int(round(-math.log10(self.step_size))) return math.floor(qty * 10**precision) / 10**precision def round_price(self, price): precision = int(round(-math.log10(self.tick_size))) return round(price, precision) def _has_base_balance(self): base = SYMBOL.replace("USDT", "") bal = float(self.client.get_asset_balance(base)["free"]) price = float(self.client.get_symbol_ticker(symbol=SYMBOL)["price"]) return bal * price > self.min_notional # ------------------------- market data -------------------------------- def get_data(self): klines = self.client.get_klines(symbol=SYMBOL, interval=TIMEFRAME, limit=200) df = pd.DataFrame(klines, columns=[ "t", "open", "high", "low", "close", "vol", "ct", "qv", "trades", "tbb", "tbq", "ignore", ]) df["close"] = df["close"].astype(float) return df def add_indicators(self, df): df["fast"] = df["close"].rolling(FAST_MA).mean() df["slow"] = df["close"].rolling(SLOW_MA).mean() delta = df["close"].diff() gain = delta.clip(lower=0).rolling(RSI_PERIOD).mean() loss = (-delta.clip(upper=0)).rolling(RSI_PERIOD).mean() df["rsi"] = 100 - 100 / (1 + gain / loss) return df def signal(self, df): prev, last = df.iloc[-2], df.iloc[-1] crossed_up = prev["fast"] <= prev["slow"] and last["fast"] > last["slow"] crossed_down = prev["fast"] >= prev["slow"] and last["fast"] < last["slow"] if crossed_up and last["rsi"] < RSI_OVERBOUGHT: return "BUY" if crossed_down: return "SELL" return "HOLD" # ------------------------- trading logic ------------------------------ def buy(self, price): usdt = float(self.client.get_asset_balance("USDT")["free"]) # Position sizing: risk RISK_PER_TRADE of balance given the stop distance risk_amount = usdt * RISK_PER_TRADE qty = risk_amount / (price * STOP_LOSS_PCT) qty = min(qty, (usdt * 0.99) / price) # cap at affordable size qty = self.round_qty(qty) if qty * price < self.min_notional: log.warning("Order too small (%.2f USDT). Skipping.", qty * price) return order = self.client.order_market_buy(symbol=SYMBOL, quantity=qty) fill = float(order["fills"][0]["price"]) log.info("BUY filled: %s @ %.2f", qty, fill) # Attach take-profit + stop-loss as an OCO order tp = self.round_price(fill * (1 + TAKE_PROFIT_PCT)) sl = self.round_price(fill * (1 - STOP_LOSS_PCT)) self.client.create_oco_order( symbol=SYMBOL, side="SELL", quantity=qty, price=str(tp), stopPrice=str(sl), stopLimitPrice=str(sl), stopLimitTimeInForce="GTC", ) log.info("OCO placed — TP: %.2f | SL: %.2f", tp, sl) self.in_position = True def close_position(self): for o in self.client.get_open_orders(symbol=SYMBOL): self.client.cancel_order(symbol=SYMBOL, orderId=o["orderId"]) base = SYMBOL.replace("USDT", "") qty = self.round_qty(float(self.client.get_asset_balance(base)["free"])) if qty > 0: self.client.order_market_sell(symbol=SYMBOL, quantity=qty) log.info("SELL filled: %s", qty) self.in_position = False # --------------------------- main loop -------------------------------- def run(self): log.info("Bot running on %s %s (testnet=%s)", SYMBOL, TIMEFRAME, TESTNET) while True: try: df = self.add_indicators(self.get_data()) sig = self.signal(df) last = df.iloc[-1] log.info("price=%.2f fast=%.2f slow=%.2f rsi=%.1f → %s", last["close"], last["fast"], last["slow"], last["rsi"], sig) if sig == "BUY" and not self.in_position: self.buy(last["close"]) elif sig == "SELL" and self.in_position: self.close_position() except BinanceAPIException as e: log.error("Binance API error: %s", e) except Exception as e: log.exception("Unexpected error: %s", e) time.sleep(LOOP_SECONDS) if __name__ == "__main__": Bot().run() ``` ## Setup 1. `pip install python-binance pandas` 2. Get free testnet keys at [testnet.binance.vision](https://testnet.binance.vision) (login with GitHub) 3. Paste keys into the script, run `python bot.py` 4. **If** you ever go live: create an API key with *spot trading only*, **never enable withdrawals**, and whitelist your IP ## How to actually make this profitable (the real work) - **Backtest first.** MA crossovers bleed money in sideways markets. You need historical data testing across different conditions before trusting any parameter set. I can write you a backtesting script for this strategy — just ask. - **Fees matter.** At 0.1% per side, a strategy that trades often can be "right" and still lose money. - **Don't over-optimize.** If you tune FAST_MA=17, SLOW_MA=43 because it backtests perfectly, you've curve-fit to the past. - **The risk management here** (2% risk per trade, fixed stop loss) is honestly more important than the entry signal. Most blown accounts die from position sizing, not bad signals. Want me to add a backtesting module, a trailing stop, a different strategy (grid, mean reversion, momentum), or Telegram notifications?

I need profitable binance trading bot code!