Monitor MT5 trader accounts for prop-firm rules

pip install requests
export FXAPIS_MONITOR_KEY="fx_live_…"    # accounts:read/write, trading:read, history:read
export FXAPIS_ENFORCER_KEY="fx_live_…"   # trading:reduce, trading:read
# account id = starting balance, ISO date the challenge started
export ACCOUNTS="0d7c1f5e-4b6a-4c1e-9f0a-2d9e8c7b6a51=100000@2026-09-01"
export DAILY_LOSS_LIMIT="0.05" MAX_DRAWDOWN_LIMIT="0.10"
python3 monitor.py

"""Check MT5 accounts against a daily loss limit and a maximum drawdown.

Rules are computed here, on your side. fxapis supplies the broker's deals and positions.
With ENFORCE=1, a breached account has every open position closed (reduce-only key).
"""
import os
import time
from datetime import datetime, timezone
from decimal import Decimal

import requests

API = os.environ.get("FXAPIS_API", "https://api.fxapis.com")
FUNDING = {"balance", "credit", "bonus"}
DAILY_LOSS_LIMIT = Decimal(os.environ.get("DAILY_LOSS_LIMIT", "0.05"))
MAX_DRAWDOWN_LIMIT = Decimal(os.environ.get("MAX_DRAWDOWN_LIMIT", "0.10"))
ENFORCE = os.environ.get("ENFORCE") == "1"


def client(key_env):
    s = requests.Session()
    s.headers["Authorization"] = f"Bearer {os.environ[key_env]}"
    return s


monitor = client("FXAPIS_MONITOR_KEY")
enforcer = client("FXAPIS_ENFORCER_KEY") if ENFORCE else None


def data(response):
    if response.status_code >= 300:
        error = response.json().get("error", {})
        raise RuntimeError(f"{response.status_code} {error.get('code')}: {error.get('message')}")
    return response.json()


def all_deals(account_id, since):
    deals, cursor = [], None
    while True:
        params = {"since": since, "limit": 200}
        if cursor:
            params["cursor"] = cursor
        body = data(monitor.get(f"{API}/v1/accounts/{account_id}/deals", params=params, timeout=60))
        deals.extend(body["data"])
        if not body["page"]["hasMore"]:
            return deals
        cursor = body["page"]["nextCursor"]


def amount(value):
    return Decimal(value) if value not in (None, "") else Decimal(0)


def trading_result(deal):
    return amount(deal["profit"]) + amount(deal["swap"]) + amount(deal["commission"]) + amount(deal["fee"])


def evaluate(starting_balance, deals, positions, day_start):
    """Pure: the numbers a rule needs, from deals and positions."""
    balance = start_of_day = starting_balance
    for deal in deals:
        change = amount(deal["profit"]) if deal["dealType"] in FUNDING else trading_result(deal)
        balance += change
        if deal["dealtAt"] < day_start:
            start_of_day += change
    floating = sum((amount(p["profit"]) + amount(p["swap"]) for p in positions), Decimal(0))
    equity = balance + floating
    return {
        "balance": balance,
        "equity": equity,
        "daily_loss": start_of_day - equity,
        "drawdown": starting_balance - equity,
        "oldest_position": min((p["observedAt"] for p in positions), default=None),
    }


def ensure_online(account_ids, timeout=120):
    data(monitor.post(f"{API}/v1/accounts/prepare", json={"accountIds": account_ids}, timeout=60))
    deadline = time.monotonic() + timeout
    waiting = set(account_ids)
    while waiting and time.monotonic() < deadline:
        for account_id in list(waiting):
            state = data(monitor.get(f"{API}/v1/accounts/{account_id}/status", timeout=30))["data"]["state"]
            if state in ("ready", "executing"):
                waiting.discard(account_id)
            elif state in ("invalid_credentials", "trading_disabled", "needs_2fa", "needs_certificate"):
                print(f"{account_id}: needs attention ({state}); not checked")
                waiting.discard(account_id)
        time.sleep(2)
    return waiting   # accounts that did not come online in time


def close_everything(account_id, positions):
    for p in positions:
        ticket = p["brokerPositionId"]
        r = enforcer.post(f"{API}/v1/accounts/{account_id}/positions/{ticket}/close", json={},
                          headers={"Idempotency-Key": f"breach:{account_id}:{ticket}"}, timeout=90)
        if r.status_code == 201:
            print(f"  closed #{ticket}")
            continue
        code = r.json().get("error", {}).get("code")
        if code == "POSITION_NOT_FOUND":
            print(f"  #{ticket} already closed")
        elif code == "ORDER_UNRESOLVED":
            print(f"  #{ticket}: close unresolved — do not resend; it is being confirmed with the broker")
        else:
            print(f"  #{ticket}: close failed with {code}; retry with the same key")


def main():
    accounts = {}
    for item in os.environ["ACCOUNTS"].split(","):
        account_id, rest = item.split("=")
        balance, started = rest.split("@")
        accounts[account_id] = (Decimal(balance), started + "T00:00:00Z")

    not_online = ensure_online(list(accounts))
    day_start = datetime.now(timezone.utc).strftime("%Y-%m-%dT00:00:00Z")   # your terms may differ

    for account_id, (starting_balance, started) in accounts.items():
        if account_id in not_online:
            print(f"{account_id}: not online, skipped")
            continue
        data(monitor.post(f"{API}/v1/accounts/{account_id}/reconcile", timeout=60))
        deals = all_deals(account_id, started)
        positions = data(monitor.get(f"{API}/v1/accounts/{account_id}/positions", timeout=30))["data"]
        m = evaluate(starting_balance, deals, positions, day_start)

        breaches = []
        if m["daily_loss"] > starting_balance * DAILY_LOSS_LIMIT:
            breaches.append(f"daily loss {m['daily_loss']:.2f}")
        if m["drawdown"] > starting_balance * MAX_DRAWDOWN_LIMIT:
            breaches.append(f"drawdown {m['drawdown']:.2f}")
        print(f"{account_id}: balance {m['balance']:.2f} equity {m['equity']:.2f} "
              f"positions {len(positions)} (oldest {m['oldest_position']})"
              + (f" BREACH: {', '.join(breaches)}" if breaches else ""))

        if breaches and ENFORCE:
            close_everything(account_id, positions)


if __name__ == "__main__":
    main()