Trading bot not working? Find the fault in this order

Short answer: When a trading bot is not working, check from cheapest to hardest: whether the process runs and reaches the exchange, the clock, the key's environment, IP and permissions, the symbol's tick, lot and minimum-value rules, rate limits, data freshness, and whether the bot's records match the exchange. This finds software faults only; it never explains why a rule loses money, and automated trading can lose money. If the message points to a regional restriction or a KYC block, stop and ask the platform, because there is nothing to fix in code.

Codes here come from official Binance Spot, Bybit V5 and Kraken documents, read on 5 November 2026. Naming a platform is not a recommendation; which platforms you may use depends on your jurisdiction and each platform's terms. For readers in Turkey, Article 99/A of Capital Markets Law No. 6362 treats activity by foreign crypto-asset platforms directed at Turkish residents as unauthorized.

Alert-side faults are in TradingView alerts not working, and Binance codes one by one in Binance API error codes.

Why is my trading bot not working? Start from the symptom

The symptom tells you which check to run first.

On a hosted product, start with its status page and support; the key and symbol checks still apply.

One fault, three names: Binance, Bybit and Kraken errors

Venues report the same fault differently, so identify the fault first, then read that venue's page.

• HTTP 200 can be a failure. A signed request with no key on 5 November 2026 returned HTTP 200 with EAPI:Invalid key on Kraken and HTTP 401 with -2014 on Binance's Spot Testnet. Bybit's testnet gave HTTP 200 with retCode 10001 on /v5/order/realtime but HTTP 401 with an empty body on /v5/account/wallet-balance, which breaks code that parses every reply as JSON.
• One 403, two meanings. Bybit's rate-limit page says a 403 reading access too frequent means wait at least 10 minutes; its integration guide says IP addresses in the US or Mainland China are restricted and also get a 403. The first is a wait; the second is a stop.
• A dead key can lock live ones. Kraken says repeating a deleted or expired key triggers EGeneral:Temporary lockout for every key from that IP, for about 20 minutes.
• A library can hide the difference. In CCXT 4.5.10, tested offline with synthetic error bodies, -1007 and 170007 raised RequestTimeout, but EService:Deadline elapsed raised the generic ExchangeError, and master (4.5.92) still has no entry for it. Kraken says that order may have been placed, so match the message as well as the class.

A read-only trading bot check you can run now

This script reads public testnet endpoints only, takes no key and cannot send an order.

# Read-only, no key: python bot_doctor.py binance|bybit SYMBOL [qty price]
import json, sys, time, urllib.error, urllib.request
from decimal import Decimal as D

BN, BY = "https://testnet.binance.vision/api/v3", "https://api-testnet.bybit.com/v5"

def bn_rules(j):
    s = j["symbols"][0]
    f = {x["filterType"]: x for x in s["filters"]}
    return (s["status"], f["PRICE_FILTER"]["tickSize"], f["LOT_SIZE"]["stepSize"],
            f["LOT_SIZE"]["minQty"], f["NOTIONAL"]["minNotional"])

def by_rules(j):
    if not j["result"]["list"]:  # unknown symbol: retCode 0 and an empty list
        sys.exit("REJECTED: unknown symbol")
    s = j["result"]["list"][0]
    lot = s["lotSizeFilter"]
    return (s["status"], s["priceFilter"]["tickSize"], lot["basePrecision"],
            lot["basePrecision"], lot["minOrderAmt"])  # minOrderQty is deprecated for spot

VENUES = {
  "binance": (BN + "/time", lambda j: j["serverTime"],
              BN + "/exchangeInfo?symbol={}", bn_rules,
              BN + "/trades?limit=1&symbol={}", lambda j: j[0]["time"]),
  "bybit": (BY + "/market/time", lambda j: int(j["result"]["timeNano"]) // 10**6,
            BY + "/market/instruments-info?category=spot&symbol={}", by_rules,
            BY + "/market/recent-trade?category=spot&limit=1&symbol={}",
            lambda j: int(j["result"]["list"][0]["time"])),
}

def fetch(url):
    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
    try:
        with urllib.request.urlopen(req, timeout=10) as r:
            status, head, body = r.status, r.headers, r.read()
    except urllib.error.HTTPError as e:
        status, head, body = e.code, e.headers, e.read()
    except OSError as e:
        sys.exit(f"UNREACHABLE: {e}")
    if status in (403, 451) or "json" not in head.get("Content-Type", ""):
        sys.exit(f"STOP HTTP {status}. If this is a regional or account block, "
                 "ask the platform.")
    data = json.loads(body or "{}")
    if status >= 400 or (isinstance(data, dict) and data.get("retCode")):
        sys.exit(f"REJECTED HTTP {status}: {body[:100]}")
    return data

def order_problems(tick, step, min_qty, min_value, qty, price):
    q, p = D(qty), D(price)
    checks = [(D(tick) and p % D(tick), f"price not a multiple of tick {tick}"),
              (D(step) and q % D(step), f"qty not a multiple of step {step}"),
              (q < D(min_qty), f"qty below minimum {min_qty}"),
              (q * p < D(min_value), f"value below minimum {min_value}")]
    return [why for failed, why in checks if failed]

def main(venue, symbol, qty=None, price=None):
    time_url, time_of, rules_url, rules_of, last_url, last_of = VENUES[venue]
    print(time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), venue)
    t0 = time.time()
    server_ms = time_of(fetch(time_url))
    offset = server_ms - (t0 + time.time()) / 2 * 1000
    verdict = "ok" if -1000 < offset <= 5000 else "FAULT: fix time sync"
    print(f"clock: server minus local {offset:+.0f} ms, {verdict}")
    status, *limits = rules_of(fetch(rules_url.format(symbol)))
    print(f"{symbol}: {status}; tick, step, min qty, min value:", *limits)
    try:
        age = max(server_ms - last_of(fetch(last_url.format(symbol))), 0) / 1000
        print(f"last public trade about {age:.0f} s old")
    except IndexError:
        print("no recent public trade returned")
    if qty and price:
        try:
            bad = order_problems(*limits, qty, price)
        except ArithmeticError:
            sys.exit("REJECTED: qty and price must be plain numbers")
        print("order check, nothing sent:", "; ".join(bad) or "passes")

if __name__ == "__main__":
    main(*sys.argv[1:])

Output of python bot_doctor.py binance BTCUSDT 0.000015 100.005 on 5 November 2026 (Python 3.11; the order values are deliberately bad):

2026-11-05T19:03:21Z binance
clock: server minus local +1124 ms, ok
BTCUSDT: TRADING; tick, step, min qty, min value: 0.01000000 0.00001000 0.00001000 5.00000000
last public trade about 4 s old
order check, nothing sent: price not a multiple of tick 0.01000000; qty not a multiple of step 0.00001000; value below minimum 5.00000000

Failure paths were tested too: a local HTML 403 and a 451 end with STOP, an HTTP 200 body error, an empty 401, an unknown symbol and bad numbers with REJECTED, a closed port with UNREACHABLE, and a clock 7 seconds behind or 2 seconds ahead prints FAULT. Key permissions, the IP allowlist and signing need a real key, so they were not run; API key security for trading bots shows a start-up permission check.

Timestamp errors: fix the host clock first

A timestamp error means the host clock is off or the request waited too long, so fix time sync before touching any window setting.

Binance and Bybit use one rule, read 5 November 2026: a signed request passes only if its timestamp is under 1 second ahead of server time and no older than the window, 5,000 ms by default. A larger window does nothing for a clock running ahead.

• Windows. Freqtrade's Docker page says a container's clock on Windows drifts into the past, causing the recvWindow error, and does not recommend that setup for production. CCXT's manual warns that turning on time sync in Windows is usually not enough.
• Nonces. Kraken rejects a nonce at or below the last accepted one, so threads sharing a key need one counter behind a mutex.
• Hosts. Bybit's 10003 message names four environments a key must match; its guide lists separate regional hosts.

Works, then stops: limits, stale streams and API changes

A bot that ran and then stopped has usually hit a limit, lost its data unnoticed or met a platform change.

A quiet market and a dead feed look identical from the socket, so compare the last data message with the last trade from REST: if REST is newer, the stream is stale. Binance's limits are in the rate limit guide. For changes, compare the date the bot last worked with the official pages:

How to set up a trading bot so faults show early

Set up five things before the first live order.

1. Restricted key. One per bot, read and trade only, never withdrawal, bound to the server's IP where allowed.
2. Time sync. Scheduled on the host, then checked with the script from inside any container.
3. Logs with no secrets. UTC time, request, response code, client order ID and raw error, with keys and signatures removed.
4. Alerts that reach a person. Missing heartbeat, reject bursts or reconnect loops, on a channel someone reads. Limits belong in trading bot risk management.
5. A small test order on testnet. Place it, cancel it and restart with it open; the full plan is in how to test trading bots.

How to use a trading bot day to day follows from this: read the alerts, keep the version you tested and treat a platform notice as a change to test. Tests show how the software behaves, not future results.

What to collect before asking for help

Collect the exact error, the time and the versions with secrets removed.

• Error: code, message, HTTP status and raw body, copied rather than retyped.
• Time and place: UTC timestamp, the script's clock line, venue, environment and host.
• Versions: bot, library, Python and operating system.
• Request: symbol, quantity, price and client order ID, with key and signature removed.
• Last change: deployment, configuration, key rotation or platform notice.

Never send API keys. If you have the source code and the right to share it, a trading bot code review starts from these items; Fincode sells that review, so this guide is not neutral, and naming Binance, Bybit or Kraken does not mean Fincode integrates them or has built on them. A regional or KYC block is different: stop and ask the platform.

Frequently asked questions

Why is my trading bot not placing orders?

Check that the process runs in live mode and logs a rule firing, then the clock, then the key's environment, IP allowlist and permissions. If orders are refused, compare the exact message with the symbol's rules.

Why does my bot work on testnet but not live?

Test and live environments use separate hosts and keys, and limits can differ. Confirm the key matches the host, then read the rules from the live environment.

My bot is losing money. Is that a fault?

Not one this guide can find. A bot that follows its rules correctly can still lose money, and this guide suggests no change to any rule or setting.

Does the diagnostic script need my API key?

No, and that is its limit: it cannot check permissions, the IP allowlist or signing.

Sources

• Binance Spot API documentation: Error codes, including filter failures (opens in a new tab)
• Binance Spot API documentation: Filters (tick, lot and notional rules) (opens in a new tab)
• Binance Spot API documentation: REST API (timing security, recvWindow) (opens in a new tab)
• Binance Spot API documentation: WebSocket streams (server ping every 20 seconds) (opens in a new tab)
• Binance Spot API: CHANGELOG (last updated 30 October 2026) (opens in a new tab)
• Bybit V5 API: Error codes (opens in a new tab)
• Bybit V5 API: Integration guidance (timestamp rule, hosts) (opens in a new tab)
• Bybit V5 API: Rate limit (HTTP 403 cases) (opens in a new tab)
• Bybit V5 API: WebSocket connect (args limits, date TBD when read on 5 November 2026) (opens in a new tab)
• Kraken Developers: Error messages (causes, fixes, temporary lockout) (opens in a new tab)
• Kraken Developers: REST introduction (HTTP status codes and the error field) (opens in a new tab)
• Kraken Developers: Get System Status (upcoming maintenance within 72 hours) (opens in a new tab)
• CCXT Manual: Error handling, RequestTimeout and InvalidNonce (opens in a new tab)
• Freqtrade documentation: Docker quickstart (Docker on Windows, recvWindow note) (opens in a new tab)
• Capital Markets Law No. 6362, consolidated text, Article 99/A (Turkish) (opens in a new tab)

This guide is general information about software and markets, not investment, legal or tax advice. Automated trading can lose money, past or backtested performance does not guarantee future results, and the rules that apply depend on your jurisdiction and your exchange's terms. Sources, checks and corrections: see the editorial policy.