Crypto Python
818 subscribers
448 photos
26 files
455 links
Алготрейдинг 🤖 , работа с API бирж и агрегаторов 🌐 , автоматизации в крипто сфере📈 🚀
Ваши предложения📝 @binance_de
Download Telegram
📌AI Market Regime Detector -
идентификатор рыночного режима с автоадаптацией стратегий 🧑‍💻

💡 Суть:🚀

Инструмент автоматически определяет текущий рыночный режим — тренд, флет, высокая волатильность, паника и пр. — и переключает используемую стратегию под этот режим в реальном времени. Использует технические индикаторы, волатильность, корреляции, объёмы и ML-модель (например, RandomForestClassifier или LSTM), чтобы определить:

🟢 Восходящий тренд → трендовая стратегия (breakout)

🔴 Нисходящий тренд → short-приоритет

🟡 Боковик → стратегия на возврат к среднему

🔵 Высокая волатильность → ожидание и широкий стоп

Паника (чёрный лебедь) → стоп всех торгов

⚙️ Что делает скрипт:🛠️

- Скачивает данные с Binance через ccxt

- Обрабатывает индикаторы (ATR, Bollinger Bands, EMA)

- Распознаёт режим рынка по ML-классификатору

- В консоли пишет: режим = "восходящий тренд" и предлагает подходящие действия

- Можно подключить к основному боту через API/файл

import ccxt
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from datetime import datetime
import time

symbol = 'BTC/USDT'
timeframe = '1h'
limit = 500

exchange = ccxt.binance()

def fetch_ohlcv(symbol, timeframe='1h', limit=500):
data = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
df = pd.DataFrame(data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
return df

def add_features(df):
df['returns'] = df['close'].pct_change()
df['volatility'] = df['returns'].rolling(window=10).std()
df['ema'] = df['close'].ewm(span=20).mean()
df.dropna(inplace=True)
return df

def label_market(df):
labels = []
for i in range(len(df)):
r = df['returns'].iloc[i]
v = df['volatility'].iloc[i]
if v > 0.01:
labels.append("volatile")
elif r > 0.002:
labels.append("bullish")
elif r < -0.002:
labels.append("bearish")
else:
labels.append("sideways")
df['label'] = labels
return df

def train_model(df):
features = df[['returns', 'volatility', 'ema']].copy()
features = (features - features.mean()) / features.std()
model = RandomForestClassifier(n_estimators=100)
model.fit(features, df['label'])
return model

def predict_current_state(model, df):
last_row = df.iloc[-1:]
features = last_row[['returns', 'volatility', 'ema']]
features = (features - df[['returns', 'volatility', 'ema']].mean()) / df[['returns', 'volatility', 'ema']].std()
prediction = model.predict(features)[0]
return prediction

def main():
df = fetch_ohlcv(symbol, timeframe, limit)
df = add_features(df)
df = label_market(df)
model = train_model(df)

while True:
df = fetch_ohlcv(symbol, timeframe, limit)
df = add_features(df)
current_signal = predict_current_state(model, df)
timestamp = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')
print(f"[{timestamp}] Текущий рыночный режим: {current_signal}")
time.sleep(60 * 60) # обновление каждый час

if __name__ == '__main__':
main()

#инструмент

📌 Подпишись  Crypto Python❗️
🔥42
📌Liquidity Pulse Divergence (LPD)🧑‍💻

💡 Идея:🚀

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

📈 Основные сигналы:💸

Buy signal: объём маркет-покупок значительно превышает продажи, но лимитные ордера на продажу продолжают расти (у кого-то крупная пассивная подача ликвидности → рынок может развернуться).

Sell signal: аналогично, но наоборот.

import ccxt
import time
from datetime import datetime

symbol = 'BTC/USDT'
exchange = ccxt.binance()
depth_limit = 5
interval_sec = 10

def get_order_book():
ob = exchange.fetch_order_book(symbol)
top_bids = sum([order[1] for order in ob['bids'][:depth_limit]])
top_asks = sum([order[1] for order in ob['asks'][:depth_limit]])
return top_bids, top_asks

def get_recent_trades():
since = exchange.milliseconds() - 60 * 1000 # последняя минута
trades = exchange.fetch_trades(symbol, since=since)
buy_volume = sum(t['amount'] for t in trades if t['side'] == 'buy')
sell_volume = sum(t['amount'] for t in trades if t['side'] == 'sell')
return buy_volume, sell_volume

def analyze_and_signal():
buy_vol, sell_vol = get_recent_trades()
bid_liq, ask_liq = get_order_book()

signal = "NEUTRAL"
if buy_vol > sell_vol * 2 and ask_liq > bid_liq * 1.5:
signal = "SHORT"
elif sell_vol > buy_vol * 2 and bid_liq > ask_liq * 1.5:
signal = "LONG"

print(f"[{datetime.now().strftime('%H:%M:%S')}] "
f"BuyVol: {buy_vol:.2f}, SellVol: {sell_vol:.2f}, "
f"BidLiq: {bid_liq:.2f}, AskLiq: {ask_liq:.2f} → Signal: {signal}")

try:
while True:
analyze_and_signal()
time.sleep(interval_sec)
except KeyboardInterrupt:
print("Остановка...")

#торговые_стратегии

📌 Подпишись  Crypto Python❗️
👍3🔥31
📌Volatility-Zone Auto-Mapper🧑‍💻

🔍 Назначение: Автоматически определяет и помечает зоны волатильности (импульсные и затухающие участки) на основе ATR и плотности свечей.

⚙️ Тип: Аналитический помощник для визуального и алгоритмического определения зон интереса (breakout, консолидация, зоны входа).

📈 Цель: Предиктивная оценка вероятности движения цены после сжатия или расширения волатильности.

🔧 Как это работает:🛠️

1. Получает исторические свечи (через ccxt).

2. Считает ATR, и отмечает участки с:

Резким ростом ATR → зона импульса

Затухающим ATR и высокой плотностью свечей → зона консолидации

3. Выводит в консоль участки времени и ценовые зоны.

4. Генерирует сигналы: BREAKOUT INCOMING, LOW VOLATILITY, HIGH RISK ENTRY, и др.

import ccxt
import pandas as pd
import numpy as np

exchange = ccxt.binance()
symbol = 'BTC/USDT'
timeframe = '5m'
limit = 500

def fetch_ohlcv():
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
return df

def calculate_atr(df, period=14):
df['hl'] = df['high'] - df['low']
df['hc'] = abs(df['high'] - df['close'].shift())
df['lc'] = abs(df['low'] - df['close'].shift())
df['tr'] = df[['hl', 'hc', 'lc']].max(axis=1)
df['atr'] = df['tr'].rolling(window=period).mean()
return df

def detect_zones(df):
zones = []
for i in range(20, len(df)):
recent = df.iloc[i-10:i]
atr_slope = (recent['atr'].iloc[-1] - recent['atr'].iloc[0]) / 10
if atr_slope > 0.05:
zones.append((df['timestamp'].iloc[i], 'IMPULSE ZONE'))
elif recent['atr'].mean() < recent['atr'].max() * 0.5:
zones.append((df['timestamp'].iloc[i], 'CONSOLIDATION ZONE'))
return zones

df = fetch_ohlcv()
df = calculate_atr(df)
zones = detect_zones(df)

print(f"🔍 Анализ зон для {symbol} ({timeframe}):\n")
for z in zones[-10:]:
print(f"{z[0]} — {z[1]}")

#инструмент

📌 Подпишись  Crypto Python❗️
🔥6❤‍🔥2👍21
📌Граф Анализа Корреляций с Аномалиями🧑‍💻

Инструмент строит живой граф взаимосвязей между криптоактивами и ищет аномалии в корреляции.

💡 Суть:🚀

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

🧠 Что делает инструмент:🛠️

- Загружает котировки 10–50 криптоактивов с Binance через ccxt.

- Строит матрицу корреляций на заданном таймфрейме.

- Находит "стабильные пары" (корреляция > 0.85).

- Следит в реальном времени за изменениями этой корреляции.

- Генерирует сигнал, если происходит "декорреляция" (например, корреляция пары BTC/ETH → 0.9 → 0.3).

import ccxt
import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt

# Настройки
symbols = ['BTC/USDT', 'ETH/USDT', 'BNB/USDT', 'XRP/USDT', 'ADA/USDT']
timeframe = '1h'
limit = 100
correlation_threshold = 0.85
decorrelation_threshold = 0.3

exchange = ccxt.binance()

# Получение закрытий
def fetch_closes(symbol):
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
df.set_index('timestamp', inplace=True)
return df['close']

# Основной процесс
def main():
prices = {}
for symbol in symbols:
try:
prices[symbol] = fetch_closes(symbol)
except Exception as e:
print(f"Ошибка при загрузке {symbol}: {e}")

df = pd.DataFrame(prices)
corr = df.corr()

# Граф корреляций
G = nx.Graph()
for i in corr.columns:
for j in corr.columns:
if i != j:
c = corr[i][j]
if abs(c) > correlation_threshold:
G.add_edge(i, j, weight=round(c, 2))

# Визуализация
nx.draw(G, with_labels=True, node_color='skyblue', edge_color='gray', font_weight='bold')
plt.title("Корреляции криптовалют")
plt.show()

# Поиск декорреляций
print("\n🚨 Сигналы декорреляции:")
for i in corr.columns:
for j in corr.columns:
if i != j:
c = corr[i][j]
if abs(c) < decorrelation_threshold:
print(f"{i} и {j} имеют слабую корреляцию: {c:.2f}")

if __name__ == "__main__":
main()

#инструмент

📌 Подпишись  Crypto Python❗️
👍42
📌Аномалия ускорения объёма”🧑‍💻

Отслеживает резкое увеличение торговой активности (объёма) за последние N интервалов и сравнивает с текущим значением.
Когда текущий объём в 3+ раза выше среднего — генерируется сигнал.

⚙️ Логика стратегии:🛠️

- Собираем исторические свечи (например, 1m).

- Рассчитываем средний объём за последние N свечей.

- Сравниваем текущий объём со средним.

- Если превышение в 3 раза — сигнал "LONG" (если свеча зелёная) или "SHORT" (если свеча красная).

- Полезна для ловли всплесков активности и начала импульсов.

🧠 Преимущества:🧨

- Подходит для интрадей/скальпинга.

- Эффективна при низкой волатильности до начала тренда.

- Простота и скорость анализа.

import ccxt
import time
from datetime import datetime

exchange = ccxt.binance()
symbol = 'BTC/USDT'
timeframe = '1m'
volume_multiplier = 3
lookback_candles = 20
sleep_interval = 60 # 1 минута

def fetch_candles():
candles = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=lookback_candles + 1)
return candles

def analyze_volume_spike():
candles = fetch_candles()

volumes = [c[5] for c in candles[:-1]] # объёмы без последней свечи
avg_volume = sum(volumes) / len(volumes)
last = candles[-1]
last_open, last_close, last_volume = last[1], last[4], last[5]

signal = None
if last_volume > avg_volume * volume_multiplier:
if last_close > last_open:
signal = 'LONG'
elif last_close < last_open:
signal = 'SHORT'

print(f"[{datetime.now().strftime('%H:%M:%S')}] "
f"LastVol: {last_volume:.2f}, AvgVol: {avg_volume:.2f} → Signal: {signal or 'NO SIGNAL'}")

while True:
try:
analyze_volume_spike()
time.sleep(sleep_interval)
except Exception as e:
print("Ошибка:", e)
time.sleep(10)

#торговые_стратегии

📌 Подпишись  Crypto Python❗️
👍7🔥1
📌Market Microstructure Pulse” (MMPulse)🧑‍💻

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

📌 Описание:🛠️

Market Microstructure Pulse (MMPulse) — это Python-инструмент, который анализирует:

1. Скорость изменения Bid/Ask-объёмов (Order Book Imbalance)

2. Спайки агрессивных маркет-ордеров

3. Изменение спреда

4. Аномалии в глубине стакана (на уровне 5+)

5. Скорость отмены лимитных ордеров (Order Book Flip)

И на основе этого выдаёт сигналы в консоль.

📈 Цель инструмента:💸

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

- Используется как индикатор для высокочастотных входов (scalping) или алгосистем со сверхточкой входа.

import ccxt
import time

exchange = ccxt.binance()
symbol = 'BTC/USDT'

def fetch_orderbook(symbol, depth=5):
ob = exchange.fetch_order_book(symbol, limit=depth)
bid_vol = sum([level[1] for level in ob['bids']])
ask_vol = sum([level[1] for level in ob['asks']])
imbalance = (bid_vol - ask_vol) / (bid_vol + ask_vol + 1e-9)
spread = ob['asks'][0][0] - ob['bids'][0][0]
return {
'bid_vol': bid_vol,
'ask_vol': ask_vol,
'imbalance': imbalance,
'spread': spread
}

def monitor_market():
print("🔍 MMPulse запущен...")
while True:
try:
data = fetch_orderbook(symbol)
imbalance = data['imbalance']
spread = data['spread']
if imbalance > 0.6:
print(f"📈 Лонг дисбаланс: {imbalance:.2f}, Spread: {spread:.2f}")
elif imbalance < -0.6:
print(f"📉 Шорт дисбаланс: {imbalance:.2f}, Spread: {spread:.2f}")
time.sleep(2)
except Exception as e:
print(f"⚠️ Ошибка: {e}")
time.sleep(3)

monitor_market()

#инструмент

📌 Подпишись  Crypto Python❗️
👍5🔥1
📌"Impulse Fade Reversal"🧑‍💻

🧠 Идея:🛠️

Использовать резкий импульс (вверх или вниз) как сигнал на потенциальное истощение движения — и зайти в противоположную сторону при подтверждении “затухания” (fade).

🔍 Условия входа:💸

1. Импульс:

Цена за последние N свечей выросла/упала более чем на X%.

Например: рост/падение > 2% за 3 свечи (5m таймфрейм).

2. Фэйд (затухание):

Последняя свеча закрывается ниже (при лонге) или выше (при шорте) тела предыдущей свечи.

Объём падает (подтверждение ослабления импульса).

3. Сигнал: 🚀

Вход в противоположную сторону.

Стоп: за экстремум импульса.

Тейк: 1.5–2× риск или возврат к средней цене.

import ccxt
import pandas as pd

exchange = ccxt.binance()
symbol = 'BTC/USDT'
timeframe = '5m'
limit = 100

def fetch_data():
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
df = pd.DataFrame(ohlcv, columns=['timestamp','open','high','low','close','volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
return df

def detect_impulse_fade(df, percent=2.0, candles=3):
df['returns'] = df['close'].pct_change(periods=candles) * 100
last_ret = df['returns'].iloc[-1]
fade = df['close'].iloc[-1] < df['close'].iloc[-2] # для лонга
signal = None

if last_ret > percent and fade:
signal = '📉 SHORT сигнал (импульс вверх, фэйд вниз)'
elif last_ret < -percent and df['close'].iloc[-1] > df['close'].iloc[-2]:
signal = '📈 LONG сигнал (импульс вниз, фэйд вверх)'

return signal

df = fetch_data()
signal = detect_impulse_fade(df)

print(f"🕒 Последняя свеча: {df['timestamp'].iloc[-1]}")
if signal:
print(signal)
else:
print(" Сигналов нет")

#торговые_стратегии

📌 Подпишись  Crypto Python❗️
👍54
📌"Alpha Tracker" — Реальное сравнение вашей стратегии с рынком🧑‍💻

📌 Идея:🧨

Инструмент позволяет в реальном времени сравнивать доходность вашей стратегии с базовым активом (например, BTC/USDT). Это помогает:

- Понять, обгоняет ли стратегия рынок (генерирует alpha).

- Измерить эффективность любой стратегии: алгоритмической, ручной, сигнальной и т.п.

- Визуализировать накопленную доходность стратегии и сравнить её с buy & hold.

💼 Что делает инструмент:🛠️

1. Вы подаёте ваши сигналы (например, список входов/выходов).

2. Скрипт рассчитывает доходность вашей стратегии.

3. Скрипт параллельно считает доходность пассивного владения активом (HODL).

4. В консоли (или графике) сравниваются кумулятивные результаты.

import ccxt
import time
import pandas as pd

# Пример входов и выходов (timestamp в секундах, тип сделки, цена будет подставляться)
# Пример: вход и выход по BTC
strategy_signals = [
{"timestamp": 1720000000, "action": "buy"},
{"timestamp": 1720005000, "action": "sell"},
{"timestamp": 1720010000, "action": "buy"},
{"timestamp": 1720020000, "action": "sell"}
]

exchange = ccxt.binance()
symbol = 'BTC/USDT'

def fetch_price_at(timestamp):
ohlcv = exchange.fetch_ohlcv(symbol, timeframe='1m', since=timestamp * 1000, limit=1)
return ohlcv[0][4] if ohlcv else None

def evaluate_strategy(signals):
returns = []
for i in range(0, len(signals)-1, 2):
buy_price = fetch_price_at(signals[i]['timestamp'])
sell_price = fetch_price_at(signals[i+1]['timestamp'])
if buy_price and sell_price:
pnl = (sell_price - buy_price) / buy_price
returns.append(pnl)
return returns

def evaluate_hodl(start_time, end_time):
buy = fetch_price_at(start_time)
sell = fetch_price_at(end_time)
return (sell - buy) / buy if buy and sell else None

# Запуск
strategy_returns = evaluate_strategy(strategy_signals)
hodl_return = evaluate_hodl(strategy_signals[0]['timestamp'], strategy_signals[-1]['timestamp'])

print("\n📊 Доходность стратегии:")
for i, r in enumerate(strategy_returns):
print(f"Сделка {i+1}: {r:.2%}")

print(f"\n📈 Доходность HODL за тот же период: {hodl_return:.2%}")
print(f"📐 Итоговое alpha: {sum(strategy_returns) - hodl_return:.2%}")

#инструмент

📌 Подпишись  Crypto Python❗️
👍71
📌Panic Bid Reversal” (PBR Strategy)🧑‍💻

📈 Стратегия ловли капитуляций с автоматическим определением "панической свечи" и входом в разворот на повышенном объёме.

🧠 Идея стратегии:🛠️

Когда происходит резкий обвал с повышенным объёмом (часто вызванный ликвидациями), рынок временно "перепродаётся".
PBR — стратегия, отслеживающая такие движения и входящая в лонг на развороте.

Условия входа в лонг:🧨

1. Свеча на 1м/5м таймфрейме:

Упала на >3% от предыдущей закрытия.

Имеет объём X выше среднего (Volume Spike).

Закрылась с фитилём снизу (низкий Close относительно Low).

2. Следующая свеча начинает рост — сигнал на вход.

📤 Выход по:💸

Take Profit = +1.5–2.5%

Stop Loss = ниже фитиля панической свечи.

import ccxt
import time
from datetime import datetime

exchange = ccxt.binance()
symbol = 'BTC/USDT'
timeframe = '1m'
limit = 50

def fetch_ohlcv():
ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
return [{
'timestamp': x[0],
'open': x[1],
'high': x[2],
'low': x[3],
'close': x[4],
'volume': x[5]
} for x in ohlcv]

def detect_panic_reversal(data):
avg_volume = sum([c['volume'] for c in data[-10:-1]]) / 9
last = data[-2]
current = data[-1]

drop = (last['close'] - last['low']) / last['close']
body = abs(last['close'] - last['open'])
wick = (last['high'] - last['low']) - body

if (last['close'] < last['open'] * 0.97 and
last['volume'] > avg_volume * 2 and
wick > body and
current['close'] > last['close']):
return True
return False

print("📡 Panic Bid Reversal Strategy запущена...")

while True:
try:
candles = fetch_ohlcv()
if detect_panic_reversal(candles):
ts = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')
print(f" [{ts}] Сигнал на лонг: Обнаружена паническая свеча с разворотом!")
time.sleep(60)
except Exception as e:
print(f"⚠️ Ошибка: {e}")
time.sleep(10)

#торговые_стратегии

📌 Подпишись  Crypto Python❗️
3👍2
📌Liquidity Sniper” — Торговля на пробой зон ликвидности по паттернам всплесков объёма🧑‍💻

📌 Идея:🧨

Вместо классических уровней поддержки/сопротивления, стратегия ищет зоны ликвидности — участки, где ранее был высокий объём + разворот. Считается, что маркетмейкеры возвращаются туда, чтобы “забрать ликвидность” перед импульсом.

⚙️ Принципы стратегии:🛠️

- Выявить свечи с аномально высоким объёмом.

- Определить “зону ликвидности” — ценовой диапазон тела такой свечи.

- Ожидать возврат в зону и входить по направлению предыдущего объёма.

- Стоп за противоположный край зоны, тейк — по ближайшему импульсу.

🔍 Условия входа в сделку:💸

1. Находится свеча с объёмом выше среднего на N свечей.

2. Цена возвращается в тело этой свечи спустя X баров.

3. Объём остаётся высоким — подтверждение интереса.

4. Открывается сделка по направлению исходного движения.

import ccxt
import pandas as pd
import pandas_ta as ta
import time

exchange = ccxt.binance()
symbol = 'BTC/USDT'
timeframe = '15m'
bars = 150
volume_multiplier = 2

def fetch_ohlcv():
ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=bars)
df = pd.DataFrame(ohlcv, columns=['time', 'open', 'high', 'low', 'close', 'volume'])
df['time'] = pd.to_datetime(df['time'], unit='ms')
return df

def detect_liquidity_zones(df):
df['avg_vol'] = df['volume'].rolling(20).mean()
df['is_liquidity_candle'] = df['volume'] > df['avg_vol'] * volume_multiplier

liquidity_zones = []
for i in range(1, len(df)):
if df['is_liquidity_candle'].iloc[i]:
zone = {
"index": i,
"price_low": df['open'].iloc[i],
"price_high": df['close'].iloc[i],
"direction": "buy" if df['close'].iloc[i] > df['open'].iloc[i] else "sell"
}
liquidity_zones.append(zone)
return liquidity_zones

def check_retest(df, zones):
current_price = df['close'].iloc[-1]
for zone in zones[-5:]: # последние 5 зон
if zone["price_low"] <= current_price <= zone["price_high"]:
print(f"\n📡 Сигнал: Retest зоны ликвидности!")
print(f"👉 Направление: {zone['direction'].upper()}")
print(f"📍 Диапазон зоны: {zone['price_low']} - {zone['price_high']}")
break

# Основной цикл
while True:
df = fetch_ohlcv()
zones = detect_liquidity_zones(df)
check_retest(df, zones)
time.sleep(60)

#торговые_стратегии

📌 Подпишись  Crypto Python❗️
👍43
📌"Order Book Dynamics Tracker" — Инструмент отслеживания изменений глубины стакана в реальном времени🧑‍💻

🧠 Что делает инструмент:🛠️

Позволяет отслеживать изменения лимитных ордеров (bid/ask) по уровням и строить метрику, показывающую поведение маркетмейкеров и крупных игроков — до появления свечи и сигнала от индикаторов.

🧪 Идея:🧨

Изменения в order book (например, внезапное исчезновение большого лимитника или появление «стены») часто предшествуют импульсным движениям. Это можно использовать для:

- определения фейковых движений,

- входа до свечного сигнала,

- выявления «стоп охоты» и проскальзываний.

import asyncio
import json
import websockets
from collections import deque

symbol = 'btcusdt'
depth_levels = 10
window = deque(maxlen=5)

async def track_orderbook():
uri = f"wss://fstream.binance.com/ws/{symbol}@depth@100ms"

async with websockets.connect(uri) as websocket:
print("📡 Подключение к Binance WebSocket...")

while True:
msg = await websocket.recv()
data = json.loads(msg)

bids = data['bids'][:depth_levels]
asks = data['asks'][:depth_levels]

bid_vol = sum([float(b[1]) for b in bids])
ask_vol = sum([float(a[1]) for a in asks])

imbalance = (bid_vol - ask_vol) / (bid_vol + ask_vol + 1e-6)
window.append(imbalance)

avg_imbalance = sum(window) / len(window)

signal = "🔼 BUY PRESSURE" if avg_imbalance > 0.25 else "🔽 SELL PRESSURE" if avg_imbalance < -0.25 else "⚖️ Neutral"

print(f"Imbalance: {avg_imbalance:.2f} → {signal}")

asyncio.run(track_orderbook())

#инструмент

📌 Подпишись  Crypto Python❗️
🔥42
📌"Миметический Сканер" (Mimetic Scanner)🧑‍💻

📌 Идея:🚀

Большинство трейдеров копируют поведение друг друга (особенно на розничных рынках). Mimetic Scanner — это инструмент, который выявляет "паттерны имитации" в действиях толпы, анализируя аномально синхронизированные движения схожих активов.

🔍 Что делает:🛠️

- Отслеживает активы одного сектора (например, 5 токенов в DeFi).

- Анализирует, насколько синхронно они совершают движения вверх или вниз (на коротких интервалах).

- Когда движение становится сверхсинхронным — генерирует сигнал: скорее всего, толпа входит "на эмоциях".

- Предлагает контртрендовую тактику (если перегрето) или подтверждение тренда (если движение подтверждается фундаментально).

🧪 Пример применения:🧨

- 4 DeFi-токена резко пошли вверх в течение 15 минут.

- Correlation Score (коэффициент синхронности) > 0.95.

- Mimetic Scanner говорит: "Толпа входит по FOMO".

Трейдер может:💸

— зашортить один из перегретых токенов
— войти на откат
— использовать в стратегии "против толпы"

import ccxt
import time
import numpy as np
from datetime import datetime

# Настройка API (можно оставить пустым, если только получение данных)
exchange = ccxt.binance({
'enableRateLimit': True,
})

# Список похожих токенов (например, DeFi)
symbols = ['UNI/USDT', 'AAVE/USDT', 'COMP/USDT', 'SNX/USDT', 'CRV/USDT']
timeframe = '1m'
limit = 30 # анализ последних 30 минут

def get_returns(symbol):
try:
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
closes = [candle[4] for candle in ohlcv]
returns = np.diff(np.log(closes)) # логарифмические доходности
return returns
except Exception as e:
print(f"Ошибка получения данных по {symbol}: {e}")
return None

def correlation_matrix(return_series):
data = [r for r in return_series if r is not None]
if len(data) < 2:
return None
matrix = np.corrcoef(data)
return matrix

def average_correlation(matrix):
if matrix is None:
return 0
n = matrix.shape[0]
upper_tri_indices = np.triu_indices(n, k=1)
return np.mean(matrix[upper_tri_indices])

while True:
print(f"\n[{datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')}] Анализируем корреляции...")
return_series = [get_returns(sym) for sym in symbols]
corr_matrix = correlation_matrix(return_series)
avg_corr = average_correlation(corr_matrix)

print(f"Средняя корреляция: {avg_corr:.2f}")

if avg_corr > 0.95:
print("🚨 Высокая синхронность! Возможен FOMO-вход толпы — рассмотрите контртрендовую сделку.")
elif avg_corr < 0.2:
print(" Движения несинхронны — рынок в поиске направления.")
else:
print("📊 Умеренная синхронность — возможен тренд с подтверждением.")

time.sleep(60)

#инструмент

📌 Подпишись  Crypto Python❗️
Please open Telegram to view this post
VIEW IN TELEGRAM
4👍3
📌"Liquidity Fragmentation Exploiter"🧑‍💻

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

1. Ликвидность на кросс-рынках (например, BTC/USDT, BTC/BUSD) различается, особенно в моменты волатильности.

2. Эта стратегия мониторит спреды и ордера на смежных рынках одного и того же актива и использует их дисбаланс как предсказатель локального движения.

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

💡 Как это работает:🛠️

Сканируются 2-3 пары одного актива: например, BTC/USDT, BTC/BUSD.

- Вычисляется спред ликвидности: разница между средними объёмами и глубиной.

- Если ликвидность уходит только из одной пары, это может означать подготовку к движению.

- Алгоритм входит в рынок через самую "устойчивую" пару, направляя сделку в сторону, куда уходит ликвидность.

import ccxt
import time

exchange = ccxt.binance()
symbol_1 = 'BTC/USDT'
symbol_2 = 'BTC/BUSD'

def get_orderbook(symbol):
book = exchange.fetch_order_book(symbol, limit=10)
bid_vol = sum([order[1] for order in book['bids']])
ask_vol = sum([order[1] for order in book['asks']])
return bid_vol + ask_vol

baseline_1 = get_orderbook(symbol_1)
baseline_2 = get_orderbook(symbol_2)

print("⚙️ Базовые значения собраны. Мониторим ликвидность...\n")

while True:
time.sleep(5)
curr_1 = get_orderbook(symbol_1)
curr_2 = get_orderbook(symbol_2)

change_1 = (curr_1 - baseline_1) / baseline_1 * 100
change_2 = (curr_2 - baseline_2) / baseline_2 * 100

print(f"[{symbol_1}] Δ ликвидности: {change_1:.2f}%")
print(f"[{symbol_2}] Δ ликвидности: {change_2:.2f}%")

if change_1 < -30 and change_2 > -10:
print("🔻 Сигнал: SHORT через BTC/BUSD (ликвидность уходит с USDT)\n")
elif change_2 < -30 and change_1 > -10:
print("🔻 Сигнал: SHORT через BTC/USDT (ликвидность уходит с BUSD)\n")
elif change_1 > 30 and change_2 < 10:
print("🔼 Сигнал: LONG через BTC/BUSD\n")
elif change_2 > 30 and change_1 < 10:
print("🔼 Сигнал: LONG через BTC/USDT\n")

#торговые_стратегии

📌 Подпишись  Crypto Python❗️
Please open Telegram to view this post
VIEW IN TELEGRAM
👍5
📌"Объем + Импульсная фильтрация по кластерам"🧑‍💻

📈 Тип стратегии: краткосрочная (intra-day или swing)

📉 Подходит для: спот и фьючерсы

⚙️ Идея: открывать сделки при резком всплеске объема в пределах узкого ценового диапазона, что указывает на скрытую аккумуляцию/распродажу — с подтверждением импульса и выхода из диапазона.

🔍 Логика стратегии:🛠️

1. Фильтр объема (Volume Spike)

Считается средний объем за последние N свечей.

Если текущий объем > x * среднего (например, 3x), переходим к следующему шагу.

2. Фильтр диапазона

Проверяем, что последние N свечей были в узком ценовом диапазоне (например, max/min < 1.5%).

3. Фильтр импульса (Breakout)

Проверяется, что текущая свеча пробивает максимум или минимум диапазона.

4. Сигнал на вход в сторону пробоя

Take-Profit можно поставить на ширину диапазона * 2,

Stop-Loss — внутри диапазона.

🧠 Преимущества:🧨

- Объем указывает на институциональные действия.

- Узкий диапазон + резкий выход — признак движения, а не шума.

- Подходит для алготрейдинга, особенно в консолидациях.

import ccxt
import numpy as np
import time

symbol = 'BTC/USDT'
timeframe = '5m'
volume_multiplier = 3
range_percent_threshold = 1.5 # %

exchange = ccxt.binance({'enableRateLimit': True})

def fetch_data():
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=30)
return np.array(ohlcv)

def analyze(data):
highs = data[:, 2]
lows = data[:, 3]
closes = data[:, 4]
volumes = data[:, 5]

last_candle = data[-1]
recent_volumes = volumes[-21:-1]
avg_volume = np.mean(recent_volumes)

if last_candle[5] < avg_volume * volume_multiplier:
return None # Нет всплеска объема

recent_high = np.max(highs[-21:-1])
recent_low = np.min(lows[-21:-1])
price_range_pct = (recent_high - recent_low) / recent_low * 100

if price_range_pct > range_percent_threshold:
return None # Диапазон был слишком широкий

close = last_candle[4]
if close > recent_high:
return 'BUY'
elif close < recent_low:
return 'SELL'
return None

while True:
try:
candles = fetch_data()
signal = analyze(candles)
if signal:
print(f"[{time.strftime('%H:%M:%S')}] 📢 Сигнал: {signal} на {symbol}")
else:
print(f"[{time.strftime('%H:%M:%S')}] Нет сигнала")
except Exception as e:
print("Ошибка:", e)

time.sleep(60)

#торговые_стратегии

📌 Подпишись  Crypto Python❗️
👍4🔥3
📌"Анализатор Необычной Волатильности и Объема (UVVA)"🧑‍💻

📌 Что делает:🛠️

- Мониторит в реальном времени сразу несколько криптовалют на предмет необычного поведения:

- резких всплесков объема,

- расширения/сжатия диапазона,

- резких изменений в волатильности,

- появления «гепов» на мелком таймфрейме.

Сигналы можно использовать для:💸

- входа в пробой,

- скальпинга,

- детектирования фейковых движений или манипуляций.

import ccxt
import numpy as np
import time

exchange = ccxt.binance({'enableRateLimit': True})
symbols = ['BTC/USDT', 'ETH/USDT', 'SOL/USDT']
timeframe = '1m'
lookback = 50
volume_threshold = 2.5 # В 2.5 раза выше среднего
range_threshold = 2.0 # В 2 раза выше среднего диапазона

def fetch_ohlcv(symbol):
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=lookback)
return np.array(ohlcv)

def analyze(symbol, data):
volumes = data[:, 5]
highs = data[:, 2]
lows = data[:, 3]
closes = data[:, 4]

avg_volume = np.mean(volumes[:-1])
last_volume = volumes[-1]
avg_range = np.mean(highs[:-1] - lows[:-1])
last_range = highs[-1] - lows[-1]

volume_spike = last_volume > avg_volume * volume_threshold
range_spike = last_range > avg_range * range_threshold

if volume_spike and range_spike:
print(f"[{symbol}] Обнаружено необычное поведение!")
print(f" Объем: {last_volume:.2f} (> {avg_volume:.2f})")
print(f" Диапазон: {last_range:.4f} (> {avg_range:.4f})")
return True
return False

while True:
print(f"\n🔍 Проверка ({time.strftime('%H:%M:%S')})")
for symbol in symbols:
try:
data = fetch_ohlcv(symbol)
analyze(symbol, data)
except Exception as e:
print(f"Ошибка с {symbol}: {e}")
time.sleep(60)

#инструмент

📌 Подпишись  Crypto Python❗️
🔥51
📌"Импульс на паузе (Impulse Pause Entry)"🧑‍💻

💡 Идея:🚀

Вход не во время импульса, а сразу после него, когда цена "замирает" в узком диапазоне. Это часто происходит перед продолжением движения.

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

- Торговли пробоев с минимальным риском

- Снижения количества ложных входов

Условия входа в сделку (лонг):

1. Импульс: свеча > X% роста (например, 1% на 1м таймфрейме)

2. Пауза: N следующих свечей с малым диапазоном и объемом

3. Выход вверх из диапазона паузы = сигнал на покупку

(для шорта — наоборот)

📉 Пример условий:💸

- Импульс: свеча выросла >1%

- Пауза: 3 свечи подряд, у которых диапазон < 0.3% и объём ниже среднего

- Если цена пробивает high импульсной свечи — входим в сделку

import ccxt
import time
import numpy as np

exchange = ccxt.binance({'enableRateLimit': True})
symbol = 'BTC/USDT'
timeframe = '1m'

impulse_threshold = 0.01 # 1% рост
pause_range_threshold = 0.003 # 0.3%
pause_candles = 3

def fetch_ohlcv(symbol):
return exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=20)

def check_impulse_pause(data):
closes = np.array([c[4] for c in data])
highs = np.array([c[2] for c in data])
lows = np.array([c[3] for c in data])
volumes = np.array([c[5] for c in data])

returns = (closes[1:] - closes[:-1]) / closes[:-1]
last_impulse_index = np.where(returns > impulse_threshold)[0]

if len(last_impulse_index) == 0:
return False

idx = last_impulse_index[-1] + 1
if idx + pause_candles >= len(closes):
return False

pause_ranges = highs[idx:idx+pause_candles] - lows[idx:idx+pause_candles]
avg_range = np.mean(closes[:-pause_candles] * pause_range_threshold)
if np.all(pause_ranges < avg_range):
breakout_price = highs[idx-1] # high импульсной свечи
current_price = closes[-1]
if current_price > breakout_price:
print(f"🚀 [{symbol}] Сигнал ЛОНГ: пробой после паузы на импульсе!")
return True
return False

while True:
try:
candles = fetch_ohlcv(symbol)
check_impulse_pause(candles)
except Exception as e:
print(f"Ошибка: {e}")
time.sleep(60)

#торговые_стратегии

📌 Подпишись  Crypto Python❗️
🔥3👍21
📌"Smart Level Radar" — Умный сканер горизонтальных уровней поддержки/сопротивления с визуальной тепловой картой"🧑‍💻

🔍 Описание:🛠️

Инструмент автоматически сканирует исторические данные (OHLCV) и находит ключевые уровни, где:

- Цена останавливалась, отскакивала или пробивала

- Объем был на пиках

- Уровень тестировался многократно

- Затем он визуализирует уровни как тепловую карту (heatmap), показывая, где на графике сконцентрировано наибольшее "внимание" рынка.

🧠 Зачем трейдеру:💸

- Позволяет быстро оценить важные уровни поддержки/сопротивления

- Упрощает принятие решений по входу/выходу

- Работает как дневной "сканер рынка" перед сессией

- Может использоваться для любых активов: BTC, альты, акции

import ccxt
import numpy as np
import matplotlib.pyplot as plt

exchange = ccxt.binance()
symbol = 'BTC/USDT'
timeframe = '1h'
limit = 1000

def fetch_ohlcv(symbol, timeframe, limit):
data = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
return np.array(data)

def detect_levels(candles, threshold=5):
highs = candles[:, 2]
lows = candles[:, 3]
levels = []

for i in range(2, len(candles) - 2):
high = highs[i]
low = lows[i]
count_high = np.sum(np.abs(highs[i-2:i+3] - high) < 0.001 * high)
count_low = np.sum(np.abs(lows[i-2:i+3] - low) < 0.001 * low)

if count_high >= threshold:
levels.append(high)
if count_low >= threshold:
levels.append(low)

return sorted(set([round(lvl, 2) for lvl in levels]))

def plot_levels(candles, levels):
timestamps = [c[0] for c in candles]
closes = [c[4] for c in candles]

plt.figure(figsize=(15, 7))
plt.plot(timestamps, closes, label='Price', color='black')
for lvl in levels:
plt.axhline(lvl, color='red', alpha=0.3)
plt.text(timestamps[0], lvl, str(lvl), color='red', fontsize=8)
plt.title('Smart Level Radar')
plt.xlabel('Time')
plt.ylabel('Price')
plt.grid(True)
plt.legend()
plt.show()

candles = fetch_ohlcv(symbol, timeframe, limit)
levels = detect_levels(candles)
plot_levels(candles, levels)

#инструмент

📌 Подпишись  Crypto Python❗️
1👍3🔥2👏1
📌Bid-Ask Spread Heatmap (Монитор ликвидности по рынку)🧑‍💻

Описание:🚀

Этот скрипт показывает спред между bid и ask ценами на топ-ликвидных парах Binance, сортируя их по уровню "узости" спреда.

Это полезно для:💸

- выявления высоколиквидных пар для алготрейдинга;

- оценки "фрикционных" затрат при входе/выходе;

- настройки стратегий арбитража и маркет-мейкинга.

import ccxt
import time

exchange = ccxt.binance()
markets = exchange.load_markets()
symbols = [s for s in markets if s.endswith('/USDT') and markets[s]['active']]

def get_spread(symbol):
try:
orderbook = exchange.fetch_order_book(symbol, limit=5)
bid = orderbook['bids'][0][0] if orderbook['bids'] else None
ask = orderbook['asks'][0][0] if orderbook['asks'] else None

if bid is None or ask is None:
return None

spread_pct = (ask - bid) / ((ask + bid) / 2) * 100
return round(spread_pct, 4)
except Exception:
return None

def main():
spreads = []
for symbol in symbols:
spread = get_spread(symbol)
if spread is not None:
spreads.append((symbol, spread))

spreads.sort(key=lambda x: x[1]) # от самого узкого спреда
print(f"\nTop 10 пар с самым узким спредом:\n{'-'*40}")
for symbol, spread in spreads[:10]:
print(f"{symbol:15} → Спред: {spread:.4f}%")

if __name__ == "__main__":
while True:
main()
time.sleep(60) # обновление раз в минуту

#инструмент

📌 Подпишись  Crypto Python❗️
👍4
📌"Liquidity Imbalance Pulse"🧑‍💻

🧠 Идея:🧨

Это не просто стратегия по индикаторам. Это модель, реагирующая на структурные изменения в стакане и ликвидности, когда происходит дисбаланс между спросом и предложением, приводящий к краткосрочным импульсам. Она:

- Использует данные ордербука (bid/ask depth)

- Сопоставляет дельту объема (агрессивные покупки/продажи)

- Отслеживает поведение цены в микроструктуре (1s–5s свечи)

- Алгоритм определяет: это ложное движение или начало реального импульса

📊 Сигналы:💸

Лонг:

- Обнаружен сильный дисбаланс: bid size резко увеличился, ask съедается маркет-ордерами

- Spread сузился

- Цена закрепляется выше локального уровня ликвидности

Шорт:

Обратная ситуация: ask усилился, маркет-продажи интенсивны, цена пробивает ликвидность вниз

import ccxt
import time
import datetime

# Настройки
symbol = 'BTC/USDT'
depth_limit = 20 # Глубина анализа стакана
imbalance_threshold = 0.5 # Чувствительность к дисбалансу
poll_interval = 3 # Интервал между проверками (сек)

# Инициализация биржи
exchange = ccxt.binance({
'enableRateLimit': True,
})

def get_orderbook_metrics():
try:
orderbook = exchange.fetch_order_book(symbol, limit=depth_limit)

bids = orderbook['bids']
asks = orderbook['asks']

bid_volume = sum([price * amount for price, amount in bids])
ask_volume = sum([price * amount for price, amount in asks])

best_bid = bids[0][0] if bids else 0
best_ask = asks[0][0] if asks else 0
spread = best_ask - best_bid
mid_price = (best_ask + best_bid) / 2 if best_bid and best_ask else 0

imbalance = (bid_volume - ask_volume) / (bid_volume + ask_volume + 1e-9)

return {
'bid_volume': bid_volume,
'ask_volume': ask_volume,
'imbalance': imbalance,
'spread': spread,
'mid_price': mid_price,
'timestamp': datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')
}

except Exception as e:
print("Ошибка при получении стакана:", str(e))
return None

def print_signal(metrics):
imbalance = metrics['imbalance']
signal = " Нейтрально"

if imbalance >= imbalance_threshold:
signal = "🟢 ЛОНГ сигнал"
elif imbalance <= -imbalance_threshold:
signal = "🔴 ШОРТ сигнал"

print(f"[{metrics['timestamp']}] {signal} | Imbalance: {imbalance:.2f} | "
f"BidVol: {metrics['bid_volume']:.0f} | AskVol: {metrics['ask_volume']:.0f} | "
f"Mid: {metrics['mid_price']:.2f} | Spread: {metrics['spread']:.2f}")

def run():
print("🚀 Старт стратегии Liquidity Imbalance Pulse\n")
while True:
metrics = get_orderbook_metrics()
if metrics:
print_signal(metrics)
time.sleep(poll_interval)

if __name__ == '__main__':
run()

#торговые_стратегии

📌 Подпишись  Crypto Python❗️
1🔥4
📌Стратегия возврата к среднему с подтверждением через ATR и Price Action🧑‍💻

Стратегия возврата к среднему в трейдинге предполагает, что цены финансовых активов имеют тенденцию возвращаться к своим историческим средним значениям после отклонений.

Основная идея:🚀

Цена временно отклоняется от скользящей средней (SMA) — если отклонение достаточно велико (например, 2×ATR), и свеча подтверждает разворот, то стратегия выдаёт сигнал.

🔧 Настройки:

- SMA: 20-периодная

- ATR: 14-периодная

- Подтверждение: свеча закрылась в сторону возврата

- Сигналы: только когда цена находится вне 2×ATR от SMA

import ccxt
import pandas as pd
import time
import datetime

# Настройки
symbol = 'BTC/USDT'
timeframe = '1h'
sma_period = 20
atr_period = 14
atr_multiplier = 2

exchange = ccxt.binance({
'enableRateLimit': True
})

def fetch_data():
ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=max(sma_period, atr_period) + 50)
df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
return df

def compute_indicators(df):
df['sma'] = df['close'].rolling(sma_period).mean()
tr = pd.concat([
df['high'] - df['low'],
(df['high'] - df['close'].shift()).abs(),
(df['low'] - df['close'].shift()).abs()
], axis=1).max(axis=1)
df['atr'] = tr.rolling(atr_period).mean()
return df

def check_signal(df):
latest = df.iloc[-1]
prev = df.iloc[-2]
upper_band = latest['sma'] + atr_multiplier * latest['atr']
lower_band = latest['sma'] - atr_multiplier * latest['atr']

# Условия для сигнала на шорт
if latest['close'] > upper_band and latest['close'] < prev['close']:
print(f"🔻 SHORT сигнал [{symbol}] @ {latest['close']} — возврат от верхней границы")

# Условия для сигнала на лонг
elif latest['close'] < lower_band and latest['close'] > prev['close']:
print(f"🔼 LONG сигнал [{symbol}] @ {latest['close']} — возврат от нижней границы")

def main():
while True:
try:
df = fetch_data()
df = compute_indicators(df)
check_signal(df)
time.sleep(60 * 60) # Ждём 1 час до следующего бара
except Exception as e:
print("Ошибка:", e)
time.sleep(60)

if __name__ == '__main__':
main()

#торговые_стратегии

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