📌 Cross Exchange Spread Monitor – Мониторинг спредов между биржами🧑‍💻

Суть стратегии:

Мониторинг разницы цен (спреда) одного и того же актива на двух и более биржах.

Используется для:

- Арбитража (если спред покрывает комиссии),

- Поиска расхождений в ликвидности,

- Реалтайм-анализа рыночной неэффективности.

import ccxt
import time

# Настройки
SYMBOL = "BTC/USDT"
THRESHOLD = 0.5  # в % — минимальный спред для сигнала
INTERVAL = 10  # сек

# Инициализация бирж
binance = ccxt.binance()
kucoin = ccxt.kucoin()

def get_price(exchange, symbol):
    try:
        return exchange.fetch_ticker(symbol)["last"]
    except Exception as e:
        print(f"{exchange.id} error:", e)
        return None

def check_spread():
    price_binance = get_price(binance, SYMBOL)
    price_kucoin = get_price(kucoin, SYMBOL)

    if price_binance and price_kucoin:
        spread = abs(price_binance - price_kucoin)
        spread_pct = spread / ((price_binance + price_kucoin) / 2) * 100

        print(f"\nBinance: {price_binance:.2f} | KuCoin: {price_kucoin:.2f} | Spread: {spread_pct:.2f}%")

        if spread_pct >= THRESHOLD:
            more = "Binance" if price_binance > price_kucoin else "KuCoin"
            print(f"⚡ Возможность арбитража: {more} дороже на {spread_pct:.2f}%")

if __name__ == "__main__":
    while True:
        check_spread()
        time.sleep(INTERVAL)

#арбитраж

📌 Подпишись  Crypto Python❗️

📌 Latency Arbitrage – Торговля с преимуществом по задержке (задержка котировок)🧑‍💻

Суть стратегии:🚀

Latency Arbitrage использует разницу во времени обновления котировок между двумя биржами (или спот/фьючерс), чтобы:

Быстро купить там, где цена ещё не обновилась,

Продать там, где цена уже ушла вверх/вниз.

Часто применяется в:

- HFT (high-frequency trading),

- На рынках с низкой ликвидностью,

- При разной скорости обновления API/WebSocket.

import ccxt
import time

# Настройки
SYMBOL = "BTC/USDT"
THRESHOLD = 0.3  # % расхождения
INTERVAL = 1  # сек

# Биржи (одна медленнее, например)
fast_exchange = ccxt.binance()
slow_exchange = ccxt.kucoin()

def get_price(exchange):
    try:
        return exchange.fetch_ticker(SYMBOL)["last"]
    except:
        return None

def check_latency_arbitrage():
    fast_price = get_price(fast_exchange)
    slow_price = get_price(slow_exchange)

    if fast_price and slow_price:
        spread = fast_price - slow_price
        spread_pct = spread / slow_price * 100

        print(f"\nFast: {fast_price:.2f} | Slow: {slow_price:.2f} | Δ: {spread_pct:.2f}%")

        if abs(spread_pct) >= THRESHOLD:
            direction = "BUY slow / SELL fast" if spread > 0 else "BUY fast / SELL slow"
            print(f"⚡ Возможность арбитража: {direction}")

if __name__ == "__main__":
    while True:
        check_latency_arbitrage()
        time.sleep(INTERVAL)

#арбитраж

📌 Подпишись  Crypto Python❗️

📌 Stablecoin Arbitrage Monitor – Мониторинг расхождений курсов стейблов на разных платформах 🧑‍💻

Суть стратегии:

Стейблкоины (например, USDT, USDC, BUSD, DAI) должны торговаться около $1, но из-за спроса/предложения и разной ликвидности цены иногда отклоняются🫰

→ Это создаёт возможность для арбитража, особенно между:

Разными стейблами (USDC/USDT, DAI/USDT),

Разными биржами (Binance, Kraken, KuCoin и др.).

import ccxt
import time

# Параметры
STABLE_PAIRS = ["USDC/USDT", "DAI/USDT", "TUSD/USDT", "BUSD/USDT"]
THRESHOLD = 0.3  # % отклонения
EXCHANGES = {
    "binance": ccxt.binance(),
    "kucoin": ccxt.kucoin(),
    "kraken": ccxt.kraken()
}
INTERVAL = 30  # сек

def get_price(exchange, symbol):
    try:
        ticker = exchange.fetch_ticker(symbol)
        return ticker['last']
    except:
        return None

def monitor_stable_arbitrage():
    while True:
        print("\n📊 Stablecoin Arbitrage Monitor")
        for pair in STABLE_PAIRS:
            prices = {}
            for name, ex in EXCHANGES.items():
                price = get_price(ex, pair)
                if price:
                    prices[name] = price

            if len(prices) < 2:
                continue

            exchanges = list(prices.keys())
            for i in range(len(exchanges)):
                for j in range(i + 1, len(exchanges)):
                    e1, e2 = exchanges[i], exchanges[j]
                    p1, p2 = prices[e1], prices[e2]
                    spread = abs(p1 - p2) / ((p1 + p2) / 2) * 100

                    if spread >= THRESHOLD:
                        print(f"⚠️ {pair} | {e1}: {p1:.4f} vs {e2}: {p2:.4f} | Spread: {spread:.2f}%")

        time.sleep(INTERVAL)

if __name__ == "__main__":
    monitor_stable_arbitrage()

#арбитраж

📌 Подпишись  Crypto Python❗️

📌 Multi-Timeframe Arbitrage – Расхождения между таймфреймами одного актива🧑‍💻

Суть стратегии:

Анализирует поведение одного актива на разных таймфреймах и ищет несогласованность сигналов, например:

На 1h — восходящий тренд (бычий сигнал)

На 5m — перепроданность и разворот вниз

→ Возможность взять контртрендовую позицию или перезайти по выгодной цене💸

Применение:🧨

Вход в лонг по старшему ТФ (например, 1h),

Ожидание отката на младшем ТФ (например, 5m)

Вход по наилучшей точке против краткосрочного импульса

import ccxt
import pandas as pd
import talib

# Настройки
EXCHANGE = ccxt.binance()
PAIR = "BTC/USDT"
TF_HIGH = "1h"
TF_LOW = "5m"
RSI_PERIOD = 14
RSI_OVERBOUGHT = 70
RSI_OVERSOLD = 30

def fetch_rsi(symbol, timeframe):
    ohlcv = EXCHANGE.fetch_ohlcv(symbol, timeframe=timeframe, limit=RSI_PERIOD + 10)
    df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])
    rsi = talib.RSI(df["close"], timeperiod=RSI_PERIOD)
    return rsi.iloc[-1]

def detect_divergence():
    rsi_high = fetch_rsi(PAIR, TF_HIGH)
    rsi_low = fetch_rsi(PAIR, TF_LOW)

    print(f"\n[RSI] {TF_HIGH}: {rsi_high:.2f} | {TF_LOW}: {rsi_low:.2f}")

    if rsi_high > 60 and rsi_low < RSI_OVERSOLD:
        print("📥 Вход в лонг: старший ТФ бычий, младший — перепродан")
    elif rsi_high < 40 and rsi_low > RSI_OVERBOUGHT:
        print("📤 Вход в шорт: старший ТФ медвежий, младший — перекуплен")
    else:
        print("⏳ Сигналов нет, таймфреймы согласованы")

if __name__ == "__main__":
    detect_divergence()

#арбитраж

📌 Подпишись  Crypto Python❗️

📌 Price Delay Arbitrage – Арбитраж при задержке обновления цен между биржами🧑‍💻

Суть стратегии:

На разных биржах котировки одного и того же актива могут обновляться с задержкой.
Если:

Биржа A уже отреагировала на движение,

А Биржа B ещё нет,
→ Можно войти на медленной бирже, пока цена не догнала.💸

Это форма low-latency арбитража, похожая на front-running, но без необходимости HFT.

import ccxt
import time

# Настройки
SYMBOL = "BTC/USDT"
THRESHOLD = 0.4  # % расхождения
INTERVAL = 1  # сек

# Биржи
fast = ccxt.binance()
slow = ccxt.kucoin()

def get_price(exchange):
    try:
        ticker = exchange.fetch_ticker(SYMBOL)
        return ticker['last'], ticker['datetime']
    except:
        return None, None

def check_price_delay_arbitrage():
    price_fast, time_fast = get_price(fast)
    price_slow, time_slow = get_price(slow)

    if not price_fast or not price_slow:
        return

    spread = price_fast - price_slow
    spread_pct = spread / price_fast * 100

    print(f"\nFast: {price_fast:.2f} ({time_fast}) | Slow: {price_slow:.2f} ({time_slow}) | Spread: {spread_pct:.2f}%")

    if abs(spread_pct) >= THRESHOLD:
        direction = "BUY slow / SELL fast" if spread > 0 else "BUY fast / SELL slow"
        print(f"⚡ Возможность арбитража! Направление: {direction}")

if __name__ == "__main__":
    while True:
        check_price_delay_arbitrage()
        time.sleep(INTERVAL)

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Synthetic Asset Arbitrage – Арбитраж между синтетическими и реальными активами🧑‍💻

Суть стратегии:🚀

Синтетические активы (например, sBTC, sETH, cETH, ibBTC) — это токены, которые отражают цену другого актива, но торгуются на других платформах (DeFi-протоколах, мостах, деривативах).

Synthetic Arbitrage предполагает:🛠️

- Покупку актива там, где он дешевле,

- Продажу эквивалентного реального или синтетического актива там, где он дороже,

- Получение прибыли из-за временных дисбалансов в цене между синтетическим и базовым активом.

❗На что обращать внимание:

- Комиссии за своп, газ, мосты

- Время подтверждения (можно проскочить окно арбитража)

- Лимит ликвидности в пуле

- Возможность обратного обмена (exit liquidity)

import ccxt
import requests

def get_binance_btc_price():
    binance = ccxt.binance()
    ticker = binance.fetch_ticker("BTC/USDT")
    return ticker['last']

def get_synthetix_sbtc_price():
    # Пример: через API 1inch или Coingecko (тут демонстрация через Coingecko)
    url = "https://api.coingecko.com/api/v3/simple/price"
    params = {"ids": "sbtc", "vs_currencies": "usd"}
    r = requests.get(url, params=params)
    return r.json()["sbtc"]["usd"]

real_btc = get_binance_btc_price()
synthetic_btc = get_synthetix_sbtc_price()

spread = synthetic_btc - real_btc
spread_pct = spread / real_btc * 100

print(f"BTC (Binance):     ${real_btc:.2f}")
print(f"sBTC (Synthetix):  ${synthetic_btc:.2f}")
print(f"Спред:             ${spread:.2f} ({spread_pct:.2f}%)")

if abs(spread_pct) > 0.5:
    print("⚠️ Обнаружена возможность арбитража")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌 ETF vs Futures Arbitrage – Арбитраж между ETF и фьючерсами🧑‍💻

Суть стратегии:🚀

ETF (биржевые фонды) отражают стоимость базового актива (например, BTC через $BITO, ETH через $ETHE), но торгуются на фондовом рынке,
в то время как фьючерсы — на срочном.

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

Риски и особенности:🛠️

- ETF может не совпадать 1:1 с базовым активом

- Комиссии и издержки по шорту (в ETF особенно)

- Требуется доступ к фондовому и фьючерсному рынку одновременно

-Задержки в исполнении или отклонения ликвидности

# Предположим, вы получаете цены из двух источников:
etf_price = 84.00     # цена BITO
futures_price = 84500 # цена BTC фьючерса

# Переводим ETF в "BTC-эквивалент"
btc_per_etf = 0.001   # условно 1 ETF = 0.001 BTC (зависит от структуры фонда)
etf_price_btc = etf_price / btc_per_etf

spread_pct = (etf_price_btc - futures_price) / futures_price * 100

print(f"BITO в BTC: ${etf_price_btc:.2f}")
print(f"BTC Futures: ${futures_price:.2f}")
print(f"Спред: {spread_pct:.2f}%")

if abs(spread_pct) > 1.0:
    print("⚠️ Возможность арбитража между ETF и фьючерсом")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Statistical Arbitrage with Cointegration – Парный трейдинг на основе коинтеграции🧑‍💻

Суть стратегии:🛠️

Коинтеграция — это статистическая связь между двумя временными рядами, где их разность (спред) остаётся стационарной, даже если сами ряды нестационарны.
Statistical Arbitrage (StatArb) на коинтеграции предполагает:

- Найти пару активов, где есть долгосрочная устойчивая связь,

- Торговать на расхождении спреда от его среднего значения,

- Шортить актив, который ушёл выше, и лонговать актив, который остался ниже.

Идеальный случай для парного трейдинга:💸

- Активы движутся вместе долгосрочно, но краткосрочно могут расходиться

- Спред между ними возвращается к своему среднему (mean-reversion)

Как определить коинтеграцию:🧨

- Тесты: Engle-Granger, Johansen Test

- Статистика: p-value < 0.05 → есть коинтеграция

- Построение регрессии спреда между двумя активами

import ccxt
import pandas as pd
import statsmodels.api as sm
from statsmodels.tsa.stattools import coint

# Получение данных
exchange = ccxt.binance()
symbol1 = "ETH/USDT"
symbol2 = "ETC/USDT"
tf = "1h"
limit = 500

ohlcv1 = exchange.fetch_ohlcv(symbol1, timeframe=tf, limit=limit)
ohlcv2 = exchange.fetch_ohlcv(symbol2, timeframe=tf, limit=limit)

df1 = pd.DataFrame(ohlcv1, columns=["ts", "open", "high", "low", "close", "volume"])
df2 = pd.DataFrame(ohlcv2, columns=["ts", "open", "high", "low", "close", "volume"])

# Синхронизация по времени
df1["ts"] = pd.to_datetime(df1["ts"], unit="ms")
df2["ts"] = pd.to_datetime(df2["ts"], unit="ms")
merged = pd.merge(df1[["ts", "close"]], df2[["ts", "close"]], on="ts", suffixes=('_eth', '_etc'))

# Тест коинтеграции
score, pvalue, _ = coint(merged["close_eth"], merged["close_etc"])
print(f"p-value коинтеграции: {pvalue:.5f}")

if pvalue < 0.05:
    print("✅ Пары коинтегрированы, можно строить стратегию!")

    # Построение спреда через регрессию
    model = sm.OLS(merged["close_eth"], sm.add_constant(merged["close_etc"])).fit()
    merged["spread"] = merged["close_eth"] - (model.params[1] * merged["close_etc"] + model.params[0])

    # Нормализация спреда (Z-скор)
    merged["z_score"] = (merged["spread"] - merged["spread"].mean()) / merged["spread"].std()

    # Генерация сигналов
    merged["signal"] = 0
    merged.loc[merged["z_score"] > 1, "signal"] = -1  # Short ETH / Long ETC
    merged.loc[merged["z_score"] < -1, "signal"] = 1  # Long ETH / Short ETC

    print(merged[["ts", "close_eth", "close_etc", "spread", "z_score", "signal"]].tail(10))
else:
    print("❌ Нет стабильной коинтеграции, пары не подходят.")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Triangular Arbitrage Bot — Арбитраж между тройкой валют на одной бирже🧑‍💻

Что такое треугольный арбитраж?🛠️

Это стратегия, при которой ты:

1. Обмениваешь валюту A на валюту B,

2. Обмениваешь валюту B на валюту C,

3. Обмениваешь валюту C обратно на валюту A.

Цель:💸

После завершения круга получить больше валюты A, чем было изначально, без риска изменения рынка.

Что нужно учитывать:🧨

- Комиссии биржи (обычно 0.075–0.1% за каждую операцию),

- Ликвидность на уровнях цен (объём в стакане),

- Время исполнения — сделки должны быть очень быстрыми,

- Минимальные лоты и требования к ордерам.

import ccxt

exchange = ccxt.binance()

symbols = ["BTC/USDT", "ETH/BTC", "ETH/USDT"]
tickers = exchange.fetch_tickers(symbols)

btc_usdt_ask = tickers["BTC/USDT"]["ask"]  # купить BTC
eth_btc_ask = tickers["ETH/BTC"]["ask"]    # купить ETH за BTC
eth_usdt_bid = tickers["ETH/USDT"]["bid"]   # продать ETH за USDT

initial_usdt = 1000

btc_amount = initial_usdt / btc_usdt_ask
eth_amount = btc_amount / eth_btc_ask
final_usdt = eth_amount * eth_usdt_bid

profit = final_usdt - initial_usdt
profit_pct = profit / initial_usdt * 100

print(f"Старт: {initial_usdt} USDT → Конец: {final_usdt:.2f} USDT")
print(f"Профит: {profit:.2f} USDT ({profit_pct:.2f}%)")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Funding Premium vs Spot Arbitrage – Арбитраж на расхождении цены фьючерса и спота🧑‍💻

Суть стратегии:🛠️

Funding Premium Arbitrage основан на разнице между:

- Ценой спотового актива (например, BTC/USDT на споте)

и ценой бессрочного фьючерса (perpetual futures),

- а также периодическим funding rate, который платится между long/short сторонами.

Цель — зарабатывать на дисбалансе, удерживая две противоположные позиции:

Long спот + Short фьючерс, или наоборот,

При этом не подвержен риску движения цены, т.к. позиции хеджированы.

Когда работает:💸

- Фьючерс торгуется с премией к споту + положительный funding rate
→ Шорт фьючерс, лонг спот → получаешь funding и арбитраж от схождения цены.

- Фьючерс торгуется со скидкой + отрицательный funding rate
→ Лонг фьючерс, шорт спот (или через заемный актив) → аналогичная логика.

Риски:❗

- Funding rate может измениться

- Плечо на фьючерсе может привести к ликвидации (если не хеджируешь правильно)

- Зависимость от ликвидности и комиссий

- Нужно маржинальное обеспечение на обе стороны

import ccxt

exchange = ccxt.binance()

# Получаем цены
spot_ticker = exchange.fetch_ticker("BTC/USDT")
future_ticker = exchange.fetch_ticker("BTC/USDT:USDT")  # Perpetual

# Funding rate
funding = exchange.fetch_funding_rate("BTC/USDT:USDT")
funding_rate = funding["fundingRate"]

# Расчёт спреда
spot_price = spot_ticker["last"]
future_price = future_ticker["last"]
spread = future_price - spot_price
spread_pct = (spread / spot_price) * 100

print(f"Спот: {spot_price}, Фьючерс: {future_price}")
print(f"Спред: {spread:.2f} USDT ({spread_pct:.2f}%)")
print(f"Funding rate: {funding_rate:.5f} (на 8 ч)")

# Условие для входа
if spread_pct > 0.5 and funding_rate > 0.0002:
    print("✅ Вход в арбитраж: лонг спот + шорт фьючерс")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Implied Volatility Spread Arbitrage – Арбитраж на расхождении реализованной и ожидаемой волатильности🧑‍💻

Суть стратегии:🛠️

Эта стратегия основана на сравнении двух типов волатильности:

1. Implied Volatility (IV) — ожидаемая волатильность, заложенная в цену опциона.

2. Realized Volatility (RV) — реализованная историческая волатильность актива за N дней.

Идея:💸

Если IV сильно выше RV → опционы переоценены → выгодно продавать волатильность (short straddle, short options).

Если RV выше IV → опционы недооценены → выгодно покупать волатильность (long straddle, long options).

Примеры инструментов:💸

- Опционы на BTC, ETH на Deribit

- Опционы на акции или индексы через брокеров (например, Interactive Brokers, TastyTrade)

- Volatility tokens (например, ETHV, BTCV) на DeFi или централизованных платформах

import ccxt, numpy as np, pandas as pd

# Получение исторических данных
exchange = ccxt.binance()
ohlcv = exchange.fetch_ohlcv("BTC/USDT", timeframe="1d", limit=60)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])

# Расчёт реализованной волатильности за 30 дней
returns = df["close"].pct_change()
rv = returns.rolling(window=30).std() * np.sqrt(365)
rv_value = rv.iloc[-1]

# Получение IV через сторонние источники (примерно, вручную)
iv_value = 0.75  # Пример: 75% implied volatility

print(f"Realized Volatility: {rv_value:.2%}")
print(f"Implied Volatility:  {iv_value:.2%}")

if iv_value > rv_value * 1.5:
    print("IV >> RV → опционы переоценены → стратегия: продажа волатильности")
elif rv_value > iv_value * 1.2:
    print("RV >> IV → опционы недооценены → стратегия: покупка волатильности")
else:
    print("Волатильности сбалансированы → без действия")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Cross-Exchange Funding Rate Arbitrage – Арбитраж на разнице ставок финансирования между биржами🧑‍💻

Суть стратегии:🛠️

Funding Rate Arbitrage использует то, что разные биржи назначают разные ставки финансирования (funding rate) на бессрочные фьючерсы (perpetual contracts).

Цель стратегии — открыть противоположные позиции на двух биржах и зарабатывать на разнице funding rate, при этом:

- Сохраняется рыночный нейтралитет (цена не важна),

- Основная прибыль идёт от разницы в выплатах между биржами.💸

import ccxt

binance = ccxt.binance()
bybit = ccxt.bybit()

symbol = "BTC/USDT:USDT"

binance_funding = binance.fetch_funding_rate(symbol)["fundingRate"]
bybit_funding = bybit.fetch_funding_rate(symbol)["fundingRate"]

spread = binance_funding - bybit_funding

print(f"Binance funding: {binance_funding:.5f}")
print(f"Bybit funding:   {bybit_funding:.5f}")
print(f"Разница (спред): {spread:.5f}")

if abs(spread) > 0.0003:  # 0.03%
    if spread > 0:
        print("✅ Лонг на Binance, шорт на Bybit — положительное арбитражное плечо")
    else:
        print("✅ Лонг на Bybit, шорт на Binance — положительное арбитражное плечо")
else:
    print("Разница мала — арбитраж невыгоден")

#арбитраж

📌 Подпишись  Crypto Python❗️

📌Volatility Arbitrage with Options – Арбитраж на расхождении implied и realized волатильности🧑‍💻

Суть стратегии:🛠️

Volatility Arbitrage — это рыночно-нейтральная стратегия, основанная на торговле ожиданиями волатильности.

Суть:🧨

> Покупаешь или продаёшь волатильность через опционы, если implied volatility (IV) сильно отличается от realized volatility (RV) базового актива.

Ключевые понятия:💻

Implied Volatility (IV) Ожидаемая рынком волатильность (в цене опциона)

Realized Volatility (RV) Фактическая историческая волатильность (напр. 30д)

Торговая логика:💸

IV ≫ RV (опционы переоценены) Продавать волатильность (short straddle/strangle)

RV ≫ IV (опционы недооценены) Покупать волатильность (long straddle/strangle)

import ccxt
import pandas as pd
import numpy as np

exchange = ccxt.binance()
ohlcv = exchange.fetch_ohlcv("BTC/USDT", "1d", limit=60)
df = pd.DataFrame(ohlcv, columns=["ts", "open", "high", "low", "close", "volume"])

# Реализованная волатильность (30д)
returns = df["close"].pct_change()
rv = returns.rolling(window=30).std() * np.sqrt(365)

print(f"Realized Volatility (30d): {rv.iloc[-1]:.2%}")

#арбитраж

📌 Подпишись  Crypto Python❗️