В трейдинге часто говорят: «Цена — это следствие, объём — это причина».
Именно так я наткнулся на одну простую, но крайне интересную закономерность: если в момент падения появляется свеча с объёмом, который в два раза превышает средний за последние 60 дней, — то на следующей свече часто начинается рост. Об этой идее упомянул довольно популярных трейдер spicy в твиттере.

Звучит почти как байка, но я решил проверить это на практике — с помощью кода, бэктеста и живой реализации на бирже.

? Идея

Гипотеза звучит просто:

Если дневная свеча красная (то есть закрылась ниже открытия)
и её объём в 2 раза больше, чем средний объём за последние 60 свечей —
то на следующей дневной свече можно открыть лонг, и к закрытию следующего дня это даст положительный результат.

То есть, мы ищем момент капитуляции — когда рынок падает, но при этом объём всплескивает, как будто кто-то крупный вышел из позиции.
И именно после таких разгрузок часто начинаются разворот

? Проверяем гипотезу: бэктест

Чтобы не верить на слово, я написал скрипт volume.py, который берёт исторические данные с Binance и проверяет, как бы стратегия работала за последние годы.

Вот код данного файла, дальше разберем за что же отвечает каждая функция:

import requests
import pandas as pd
import matplotlib.pyplot as plt
from binance.client import Client 
import time
SYMBOL = "ETHUSDT"
LIMIT = 2500          # число свечей для загрузки
VOLUME_LOOKBACK = 60
VOLUME_MULTIPLIER = 2.0

BINANCE_KLINES_URL = "https://api.binance.com/api/v3/klines"


def fetch_klines(symbol='BTCUSDT', interval='5m', total_bars=1200, client=None):
    if client is None:
        client = Client()

    limit = 1000
    data = []
    end_time = None

    while len(data) < total_bars:
        bars_to_fetch = min(limit, total_bars - len(data))

        try:
            klines = client.futures_klines(
                symbol=symbol,
                interval=interval,
                limit=bars_to_fetch,
                endTime=end_time
            )
        except Exception as e:
            print("Binance API Error:", e)
            break

        if not klines:
            break

        data = klines + data
        end_time = klines[0][0] - 1
        time.sleep(0.1)

    df = pd.DataFrame(data, columns=[
        'timestamp', 'open', 'high', 'low', 'close', 'volume',
        'close_time', 'quote_asset_volume', 'number_of_trades',
        'taker_buy_base', 'taker_buy_quote', 'ignore'
    ])
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    df[['open','high','low','close','volume']] = df[['open','high','low','close','volume']].astype(float)
    df = df.drop_duplicates('timestamp')
    df = df.sort_values('timestamp').reset_index(drop=True)
    return df


def backtest(df):
    results = []
    for i in range(VOLUME_LOOKBACK, len(df) - 1):
        prev_60 = df.iloc[i - VOLUME_LOOKBACK:i]
        cur = df.iloc[i]
        next_bar = df.iloc[i + 1]

        avg_vol = prev_60["volume"].mean()
        is_red = cur["close"] < cur["open"]
        vol_ok = cur["volume"] >= VOLUME_MULTIPLIER * avg_vol

        if is_red and vol_ok:
            entry = next_bar["open"]
            exit_ = next_bar["close"]
            ret = (exit_ - entry) / entry * 100.0  # проценты
            results.append({
                "signal_time": cur["timestamp"],
                "entry_time": next_bar["open"],
                "entry": entry,
                "exit": exit_,
                "ret_%": ret,
            })
    return pd.DataFrame(results)


def main():
    df = fetch_klines(SYMBOL, "1d", 2500)
    bt = backtest(df)

    if bt.empty:
        print("Сигналов не найдено.")
        return

    print(f"Сделок: {len(bt)}")
    wins = (bt["ret_%"] > 0).sum()
    losses = (bt["ret_%"] <= 0).sum()
    total = bt["ret_%"].sum()
    print(f"Побед: {wins}, поражений: {losses}, общая доходность: {total:.2f}%")

    bt["equity_%"] = bt["ret_%"].cumsum()
    bt[["signal_time", "ret_%", "equity_%"]].tail(10).to_string(index=False)
    print(bt[["signal_time", "ret_%", "equity_%"]].tail(10))

    plt.figure(figsize=(10, 5))
    plt.plot(bt["signal_time"], bt["equity_%"], label="Equity (%)")
    plt.title(f"Backtest {SYMBOL} | {len(bt)} trades")
    plt.xlabel("Date")
    plt.ylabel("Equity %")
    plt.grid(True)
    plt.legend()
    plt.show()


if __name__ == "__main__":
    main()

Переменные в начале файла

• SYMBOL = "ETHUSDT" — торговая пара, для которой делаем тест.

• LIMIT = 2500 — общее число свечей.

• VOLUME_LOOKBACK = 60 — длина окна среднего объёма (60 дней).

• VOLUME_MULTIPLIER = 2.0 — множитель объёма (в твоём вопросе — 2×).

• BINANCE_KLINES_URL = "https://api.binance.com/api/v3/klines" — публичный URL Binance (в коде используется binance.client, но ссылка тут для справки).

fetch_klines(symbol='BTCUSDT', interval='5m', total_bars=1200, client=None)

Что делает:
Загружает исторические свечи через официальную библиотеку binance.client.Client. Поддерживает постраничную загрузку (пока не набрано total_bars). Возвращает DataFrame pandas с колонками: timestamp, open, high, low, close, volume.

Выход: pd.DataFrame с колонками свечей и приведёнными числовыми типами (float) и timestamp как datetime.

Особенности и подводные камни:

• Функция использует client.futures_klines, т.е. берёт фьючерсные свечи. Для спот-данных нужно использовать client.get_klines.

• В цикле данных формируется data = klines + data и end_time = klines[0][0] - 1. Это классический подход «скачать старые бары, вести список снизу вверх».

• Есть time.sleep(0.1) между запросами чтобы не спамить API.

• Если Binance вернёт ошибку — выводится сообщение и загрузка прерывается.

backtest(df)

Что делает:
Прогоняет стратегию по DataFrame со свечами. Для каждой свечи i (начиная с индекса VOLUME_LOOKBACK) проверяет условие на свечу i (она является тем самым "падением + большой объём"). При выполнении — считается вход на следующей свече i+1 по open и выход в конце следующей свечи (close). Возвращает DataFrame с результатами по всем сделкам.

Логика шагов:

1. Берём окно prev_60 = df.iloc[i - VOLUME_LOOKBACK:i] — предыдущие 60 свечей до текущей.

2. cur = df.iloc[i] — свеча, которую проверяем на условие (красная + объём).

3. next_bar = df.iloc[i + 1] — свеча, в которой мы входят (open) и закрываем (close).

4. avg_vol = prev_60["volume"].mean()

5. is_red = cur["close"] < cur["open"]

6. vol_ok = cur["volume"] >= VOLUME_MULTIPLIER * avg_vol

7. Если обе — вычисляется процентный результат ret = (exit_ - entry) / entry * 100.0 и добавляется в results.

Возвращаемое значение: pd.DataFrame(results) с колонками: signal_time, entry_time (в коде — число open, но лучше — timestamp), entry, exit, ret_% (в %).

Особенности:

• Скрипт использует next_bar["open"] и next_bar["close"] — то есть без lookahead (проверяем t и используем t+1).

• Если i + 1 выходит за пределы — цикл ограничен len(df) - 1, чтобы избежать выхода за границы.

• Этот backtest — простая однопозиционная симуляция без комиссий. Но их можно будет посчитать даже вручную.

main() в volume.py

Что делает:

1. Загружает свечи через fetch_klines(SYMBOL, "1d", 2500).

2. Вызывает backtest.

3. Если результатов нет — печатает сообщение.

4. Считает количество сделок, побед/поражений, и суммарную доходность (просто сумма процентов).

5. Добавляет колонку equity_% как кумулятивную сумму ret_%.

6. Печатает последние 10 строк таблицы и строит график equity.

Особенности:

• total = bt["ret_%"].sum() — это суммарный процент, но не учитывает компаундинг (компаундинг можно имитировать, применив рост к балансу).

• plt.show() открывает окно с графиком — при запуске на сервере без GUI можно сохранить в файл (plt.savefig()) вместо show().

? Результаты

Бэктест по ETHUSDT показал:

Сделок: 60
Побед: 36, поражений: 24
Общая доходность: 94.60%

Всего за 5 лет было 60 таких истуаций. Винрейт при этом составил 60%.

Ну и допустим, наша позиция 1000$. Комиссия на тир1 биржах (общая) 0,1-0,11%. Тогда она составит 1$ на позицию. Прирост капитала 946$, а комиссия 60$. Итого 886$ прибыли.

Также я предоставляю специальные условия для регистрации на BingX в диалогах/телеграме. По ссылке будет полный возврат реферальных комиссий для моих читателей, комиссия составим 0,5% и тогда прирост составит 916$.

Причём обратите внимание, что максимальная просадка по этой стратегии в моменте всего 20% для equity. Это не так много, и в целом мы можем говорить о том, что прибыль вполне стабильна. Это бектест по ETHUSDT (etherium). По биткоину результат следующий:

Побед: 41, поражений: 22, общая доходность: 84.26%

Впринципе результаты похожие, но обратите внимание что максимальная просадка около 10%. Мне такой расклад нравится больше, поэтому в реальном бота остановимся на BTC.

Комиссии - один из главных врагов в торговле. Поэтому буду использовать bingx чтобы снизить потери на комиссионные. Вы также можете использовать, например, bybit. API bybit проще для новичков, так что без проблем сможете отредактировать код под него.

Для bingx я создаю отдельный клиент, он используется мной во всех скриптах и выглядит следующим образом:

import time, hmac, hashlib, requests, json

class BingxClient:
    BASE_URL = "https://open-api.bingx.com"

    def __init__(self, api_key: str, api_secret: str, symbol: str = None):
        self.api_key = api_key
        self.api_secret = api_secret
        self.symbol = self._to_bingx_symbol(symbol) if symbol else None
        self.time_offset = self.get_server_time_offset()

    def _to_bingx_symbol(self, symbol: str) -> str:
        if symbol[:-5] != '-USDT':
            return symbol.replace("USDT", "-USDT")
        else:
            return symbol 

    def _sign(self, query: str) -> str:
        return hmac.new(self.api_secret.encode("utf-8"),
                        query.encode("utf-8"),
                        hashlib.sha256).hexdigest()

    def _request(self, method: str, path: str, params=None):
        if params is None:
            params = {}
        sorted_keys = sorted(params)
        query = "&".join([f"{k}={params[k]}" for k in sorted_keys])
        signature = self._sign(query)
        url = f"{self.BASE_URL}{path}?{query}&signature={signature}"
        headers = {"X-BX-APIKEY": self.api_key}
        r = requests.request(method, url, headers=headers)
        r.raise_for_status()
        return r.json()

    def _public_request(self, path: str, params=None, timeout: int = 10):
        url = f"{self.BASE_URL}{path}"
        r = requests.get(url, params=params, timeout=timeout)
        r.raise_for_status()
        return r.json()

    def get_server_time_offset(self):
        url = f"{self.BASE_URL}/openApi/swap/v2/server/time"
        r = requests.get(url)
        r.raise_for_status()
        data = r.json()
        if data.get("code") == 0:
            server_time = int(data["data"]["serverTime"])
            local_time = int(time.time() * 1000)
            return server_time - local_time
        return 0

    # ============= Полезные методы =============

    def get_mark_price(self, symbol=None):
        path = "/openApi/swap/v2/quote/premiumIndex"
        s = symbol or self.symbol
        params = {'symbol': s}
        try:
            data = self._public_request(path, params)
            if data.get('code') == 0 and 'data' in data:
                # проверяем, что data это список
                if isinstance(data['data'], list) and len(data['data']) > 0:
                    mark_price = data['data'][0].get('markPrice')
                    return float(mark_price) if mark_price is not None else None
                elif isinstance(data['data'], dict):
                    mark_price = data['data'].get('markPrice')
                    return float(mark_price) if mark_price is not None else None
            return None
        except Exception as e:
            return None

    def get_positions(self, symbol=None):
        s = symbol or self.symbol
        return self._request("GET", "/openApi/swap/v2/user/positions", {"symbol": s}).get("data", [])

    def place_market_order(self, side: str, qty: float, symbol: str = None, stop: float = None, tp: float = None):
        side_param = "BUY" if side == "long" else "SELL"
        s = symbol or self.symbol

        params = {
            "symbol": s,
            "side": side_param,
            "positionSide": "LONG" if side == "long" else "SHORT",
            "type": "MARKET",
            "timestamp": int(time.time()*1000) + self.get_server_time_offset(),
            "quantity": qty,
            "recvWindow": 5000,
            "timeInForce": "GTC",
        }

        # добавляем стоп, если указан
        if stop is not None:
            stopLoss_param = {
                "type": "STOP_MARKET",
                "stopPrice": stop,
                "price": stop,
                "workingType": "MARK_PRICE"
            }
            params["stopLoss"] = json.dumps(stopLoss_param)

        # добавляем тейк, если указан
        if tp is not None:
            takeProfit_param = {
                "type": "TAKE_PROFIT_MARKET",
                "stopPrice": tp,
                "price": tp,
                "workingType": "MARK_PRICE"
            }
            params["takeProfit"] = json.dumps(takeProfit_param)

        return self._request("POST", "/openApi/swap/v2/trade/order", params)

Тут просто прописаны и связаны все функции из документации в один класс, чтобы я мог без проблем импортировать данный код и пне переписывать каждый раз одни и те же функции.

Теперь давайте приступим к основной логике. К нашему бектест коду прибавится только ежедневная подгрузка свечей и проверка их объёма, а также функция открытия позиций.

Основной скрипт

Для начала сделаем конфиг и инициализируем биржу:

import time 
import requests 
import datetime as dt 
from decimal import Decimal 
from bingx_client import BingxClient # твой клиент BingX 

# --------------- Конфигурация ----------------- 
API_KEY = "ENTER API KEY" 
API_SECRET = "ENTER API SECRET" 
SYMBOL = "BTCUSDT" 
VOLUME_LOOKBACK = 60 
VOLUME_MULTIPLIER = 2.0 
QTY = 5 # 5eth = 20k $ 
QTY_USDT = None # можно вместо QTY указать сумму в USDT 
BINANCE_KLINES_URL = "https://api.binance.com/api/v3/klines" 

bx = BingxClient(api_key=API_KEY, api_secret=API_SECRET, symbol=SYMBOL)

Указали все нужные нам параметры и инициализировали самодельный клиент биржи. При необходимости можно изменить символ, например, на ETHUSDT и установить необходимый нам qty - количество токена либо USDT (QTY_USDT) на позицию.

Далее перейдём к написанию функций.

? 1. Подгрузка дневных свечей

В бэктесте мы использовали binance.client, но в боевом коде сделаемподгрузку напрямую через HTTP-запросы — это лучше: меньше зависимостей и быстрее инициализация. Так как скрипт работает с дневными свечами, я решил что это более надежный вариант - не зависим от клиента бинанса.

Что происходит:

• отправляется GET-запрос на эндпоинт https://api.binance.com/api/v3/klines;

• параметры: торговая пара (symbol), интервал (1d — дневные свечи) и limit (сколько последних свечей загрузить);

• Binance возвращает список, где каждая свеча — это массив из 12 чисел (open time, open, high, low, close, volume, …);

• функция возвращает этот «сырой» JSON.

Почему 61 свеча?
Потому что мы анализируем последние 60 свечей для среднего объёма + 1 закрытую свечу (для проверки условия).

2. Преобразование свечей

Дальше идёт маленькая, но важная функция:

def parse_kline(k):
    return {
        "open_time": int(k[0]),
        "open": float(k[1]),
        "close": float(k[4]),
        "volume": float(k[5]),
        "close_time": int(k[6]),
    }

Она делает JSON читаемым:

• превращает строковые числа в float;

• оставляет только нужные поля — open, close, volume и время.

Результат — список словарей, по которым дальше удобно делать математику: сравнивать, усреднять, проверять условия.

? 3. Проверка условий входа

После загрузки и парсинга свечей, мы выбираем:

last_closed = parsed[-2]       # последняя закрытая свеча (t)
prev_60 = parsed[-2 - VOLUME_LOOKBACK:-2]  # 60 свечей до неё

Затем:

avg_vol = average_volume(prev_60)
is_red = is_red_candle(last_closed)
vol_ok = last_closed["volume"] >= VOLUME_MULTIPLIER * avg_vol

• average_volume просто считает среднее за последние 60 дней;

• is_red_candle проверяет close < open;

• vol_ok — условие сильного всплеска объёма (≥2× среднего).

Если обе проверки пройдены — это наш торговый сигнал.

? 4. Открытие позиции

Когда условие выполнено, запускается блок:

bx.place_market_order(side="long", qty=qty_to_use, symbol=SYMBOL)
print("LONG открыт.")

Здесь bx — это экземпляр класса BingxClient, который подключён к API.
Он знает ключи, умеет подписывать запросы и отправлять ордера.

• side="long" → внутри клиента конвертируется в side_param = "BUY".

• type="MARKET" → ордер сразу исполняется по рыночной цене.

• positionSide="LONG" → важно для фьючерсов: отличает направление позиции.

• quantity=qty_to_use → количество ETH, которое задаём в настройках (QTY = 5)

⚙️ BingXClient внутри добавляет timestamp и подпись HMAC, формирует запрос к /openApi/swap/v2/trade/order, и биржа возвращает подтверждение об исполнении ордера

⏰ 5. Ожидание и закрытие позиции

После открытия идёт пауза ровно до следующего открытия дня:

secs = seconds_until_next_daily_open()
time.sleep(secs + 2)

Функция seconds_until_next_daily_open() вычисляет, сколько секунд осталось до следующего 00:00 UTC.
Мы добавляем +2, чтобы не попасть в момент пересчёта свечи и не словить ошибку API.

Как только наступает новый день — скрипт закрывает позицию:

bx.place_market_order(side="short", qty=qty_to_use, symbol=SYMBOL)
print("Позиция закрыта на открытии следующей свечи.")

Здесь мы просто открываем рыночный ордер «в обратную сторону» —
для фьючерсов это означает закрытие текущей позиции (если до этого был LONG — теперь SELL).

? 6. Цикличность

Всё это помещено в бесконечный цикл while True:,
чтобы бот непрерывно работал каждый день:

• ждёт открытия новой свечи;

• проверяет условие;

• если сигнал есть — торгует;

• если нет — просто ждёт следующего дня.

В конце стоит except Exception as e: ... time.sleep(60) —
это страховка от сбоев (например, временно не ответил API Binance или BingX).
Бот подождёт минуту и продолжит.

Полный код:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Обновлённая стратегия:
1. Скрипт ждёт открытия новой дневной свечи (в 00:00 UTC).
2. В момент открытия новой свечи проверяет предыдущую свечу:
   - если она красная (close < open)
   - и объём >= 2 × среднего за 60 предыдущих свечей
   -> открывает LONG (market) в текущий момент (открытие новой свечи).
3. Держим позицию до открытия следующей дневной свечи (00:00 UTC следующего дня),
   затем закрываем (market).
"""

import time
import requests
import datetime as dt
from decimal import Decimal
from bingx_client import BingxClient  # твой клиент BingX

# --------------- Конфигурация -----------------

API_KEY = "BINGX API KEY"
API_SECRET = "BINGX API SECRET"

SYMBOL = "ETHUSDT"
VOLUME_LOOKBACK = 60
VOLUME_MULTIPLIER = 2.0

QTY = 0.05
QTY_USDT = None  # можно вместо QTY указать сумму в USDT

BINANCE_KLINES_URL = "https://api.binance.com/api/v3/klines"
# ------------------------------------------------

bx = BingxClient(api_key=API_KEY, api_secret=API_SECRET, symbol=SYMBOL)

def fetch_daily_klines(symbol: str, limit: int = 61):
    params = {"symbol": symbol, "interval": "1d", "limit": limit}
    r = requests.get(BINANCE_KLINES_URL, params=params, timeout=10)
    r.raise_for_status()
    return r.json()


def parse_kline(k):
    return {
        "open_time": int(k[0]),
        "open": float(k[1]),
        "close": float(k[4]),
        "volume": float(k[5]),
        "close_time": int(k[6]),
    }


def average_volume(klines):
    vols = [k["volume"] for k in klines]
    return sum(vols) / len(vols) if vols else 0


def is_red_candle(k):
    return k["close"] < k["open"]


def seconds_until_next_daily_open(now_utc=None):
    """Возвращает количество секунд до следующего 00:00 UTC"""
    if now_utc is None:
        now_utc = dt.datetime.utcnow()
    tomorrow = (now_utc + dt.timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
    delta = (tomorrow - now_utc).total_seconds()
    return max(0, delta)


def wait_until_daily_open():
    """Ждём до следующего 00:00 UTC"""
    secs = seconds_until_next_daily_open()
    if secs > 0:
        print(f"Ждём до открытия следующей дневной свечи ({secs:.0f} сек)...")
        time.sleep(secs + 2)  # +2 сек для уверенности


def compute_qty_from_usdt(bx: BingxClient, symbol: str, qty_usdt: float):
    mark = bx.get_mark_price(symbol)
    if not mark:
        raise RuntimeError("Не удалось получить mark price")
    qty = float(qty_usdt) / float(mark)
    qty = float(Decimal(qty).quantize(Decimal("0.000001")))
    return qty


def main():
    
    print("Запуск стратегии. Ожидаем открытия новой дневной свечи...")

    while True:
        try:
            # Ждём до открытия новой свечи
            wait_until_daily_open()

            # Когда новая свеча открылась — берём последние 61 свечу
            raw = fetch_daily_klines(SYMBOL, limit=61)
            parsed = [parse_kline(k) for k in raw]

            last_closed = parsed[-2]  # предыдущая (закрытая) свеча
            prev_60 = parsed[-2 - VOLUME_LOOKBACK:-2]

            avg_vol = average_volume(prev_60)
            is_red = is_red_candle(last_closed)
            vol_ok = last_closed["volume"] >= VOLUME_MULTIPLIER * avg_vol

            print(
                f"[{dt.datetime.utcnow().isoformat()}] Проверка предыдущей свечи:"
                f" open={last_closed['open']} close={last_closed['close']} "
                f"vol={last_closed['volume']:.2f} (avg={avg_vol:.2f})"
            )

            if is_red and vol_ok:
                print("Условие выполнено — открываем LONG.")

                qty_to_use = QTY
                if qty_to_use is None and QTY_USDT:
                    qty_to_use = compute_qty_from_usdt(bx, SYMBOL, QTY_USDT)
                    print(f"Рассчитанное qty из {QTY_USDT} USDT: {qty_to_use}")
                if qty_to_use <= 0:
                    print("Ошибка: qty <= 0, не открываем сделку.")
                    continue

                bx.place_market_order(side="long", qty=qty_to_use, symbol=SYMBOL)
                print("LONG открыт.")

                # Ждём до следующего открытия дневной свечи (т.е. 24 часа)
                secs = seconds_until_next_daily_open()
                print(f"Ждём до закрытия позиции ({secs / 3600:.2f} часов)...")
                time.sleep(secs + 2)

                # Закрываем (market SELL)
                bx.place_market_order(side="short", qty=qty_to_use, symbol=SYMBOL)
                print("Позиция закрыта на открытии следующей свечи.")
            else:
                print("Условие не выполнено. Ждём следующего дня.")

        except Exception as e:
            print("Ошибка:", e)
            time.sleep(60)


if __name__ == "__main__":
    main()

⚙️ Итог: как всё работает вместе

1. Ждём 00:00 UTC.

2. Загружаем 61 дневную свечу с Binance.

3. Проверяем:

   • последняя свеча была красной;

   • объём ≥ 2× среднего за 60 предыдущих.

4. Если условие выполнено → открываем лонг через BingX API.

5. Ждём 24 часа, пока откроется новая дневная свеча.

6. Закрываем позицию.

7. Возвращаемся к пункту 1.

? Итог

В этой статье я показал, как из простой рыночной идеи можно вырастить полноценную стратегию — от гипотезы до рабочего бота.

Всё началось с наблюдения: когда рынок падает на повышенных объёмах, часто за этим следует отскок.

Я проверил это через бэктест — и получил статистически значимое преимущество:
60 сделок, 36 прибыльных, общая доходность почти +95% по ETHUSDT. Аналогично и по BTCUSDT, только с меньшей просадкой - его мы и выбрали для основной стратегии.

Дальше — автоматизация.
Я написал основной скрипт, который подключается к API BingX,
сам ждёт открытия новой дневной свечи, проверяет условия,
и при их выполнении открывает и закрывает сделки полностью в автоматическом режиме.

BingX стал отличным выбором —
комиссия всего 0.05%, API стабилен. Для удобства - написал bingxClient, где есть все нужные для алго функции.

На выходе получился минималистичный, но честный подход:

• без десятков индикаторов,

• без сложных параметров оптимизации,

• с прозрачной логикой и воспроизводимым результатом.

И самое главное — всё подкреплено цифрами, а не интуицией.
Эта стратегия на дистанции может приносить отличный доход, особенно с максимальной просадкой в 10%. Ведь при такой просадке мы можем выставить для позиции 3-5 плечо, что кратко поднимет нашу прибыль, и уже сможем получать около 80% годовых. И всё же, без плеча это отличная консервативная стратегия, которая подойдет каждому.