Şaka lan şaka 65k filan değil bedava bedava alan yok mu. Bu kategoride çok alçak adam var. Gençler kendinizi soydurmayın, bu kategoride alçak adamlarda var ama düzgün insanlarda var. Direkt etiketle yorum iste bu kadar ya. Kimseye güvenmeyin hemşerim, bir şey satan adamdan uzak durun, satmayan adamlara danışın. Satan adamda hakkını verecek kardeşim, bu sistem alınır dedirtecek. Ama fahiş fiyat olmayacak nedir ya 10 bin dolarlar filan, yok 200 dolarlar 140 dolarlar 2000 dolarlar. Millette para yok zaten, sattığında bir boqa yarasa bari.
Kriptoda veya ticarette veya aşkta, veya santraçda kazanmak istiyorsanız, risk yönetimi sistemlerini çok iyi öğrenin.
Bakın şimdi finans alanında nobel ödülü alan Harry Markowitz, Modern Portföy Teorisi'nin (MPT) kitabından bir anektöt paylaşacağım.
"Kendi emeklilik birikimimi nasıl yatırdığımı düşünmeye başladım. Eğer beklentilerim hakkında gerçekten yüksek bir güvenim olsaydı, teorinin gerektirdiği gibi, portföyümü tek bir hisse senedine yatırmam gerekirdi. Ama ben 'Markowitz' kurallarını takip ettim, çeşitli hisse senetleri ve tahvil arasına yarı yarıya dağıtım yaptım. Portföyümü oluştururken aklımdan geçen şuydu: 'Kahrolası Markowitz, piyasanın ne yapacağını gerçekten bilmiyorsun ki!' "
Kısacası burada "piyasayı kesin olarak tahmin etmenin imkansız olduğunu" vurgulanıyor. Nobel ödülü alan adam bunu diyor. Marketi piyasayı tahmin edemezsin. Algoritma strateji önemli ama riski yönetmek de çok önemli.
Gelelim koda:
Binance futures anlık olarak izler. Tüm marketi. min_trade_value=40000.0 parametresi, balina olarak tabir edilen yüklü miktarlı (40.000 USD) işlemleri filtreler. Bunu 1 milyon olarak değiştirebilirsin mesala.
İşlem değerini 24 saatlik toplam hacme oranlayarak (Volume Impact) o işlemin piyasa üzerindeki anormalliğini tespit eder.
trade_data['m'] (is buyer maker) bayrağını kullanarak, işlemin agresif alım (BUY) mı yoksa agresif satım (SELL) mı olduğunu belirler.
Binance Futures'ın WebSocket stream'ine bağlanarak tüm coinleri anlık olarak izler.
Bot, önce tüm sembollerin (USDT bazlı Futures) listesini alır ve ardından @aggTrade stream'lerine abone olur.
Tespit edilen sinyalleri konsola (veya log dosyasına) basar.
Para kazanılır mı tabiki kazanırsın ama riskini yönetirsen. Yönetemezsen olmaz kısacası. Yatırım tavsiyesi değildir.
Başka sorusu olan ?
import asyncio
import websockets
import json
import logging
from datetime import datetime
from collections import defaultdict, deque
from typing import Dict, List, Optional
# Logging ayarları - Sadece INFO ve üzeri
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
class BinanceTradeMonitor:
def __init__(self, min_trade_value: float = 20000.0, excluded_symbols: List[str] = None):
"""
Binance Futures trade impact monitor
Args:
min_trade_value: Minimum trade value in USD to log trades (default: 20000.0)
excluded_symbols: List of symbols to exclude from monitoring and output
"""
self.min_trade_value = min_trade_value
self.excluded_symbols = set(excluded_symbols or [])
self.symbol_volumes = {} # Current 24h volume data for each symbol
self.pending_trades = defaultdict(list) # Trades waiting for volume data
self.volume_history = defaultdict(lambda: deque(maxlen=100)) # Volume history for each symbol
self.ws_url = "wss://fstream.binance.com/ws/"
def calculate_trade_impact(self, price: float, quantity: float, volume_24h: float) -> float:
"""Calculate trade impact as percentage of 24h volume"""
trade_value = price * quantity
if volume_24h > 0:
return (trade_value / volume_24h) * 100
return 0
def process_trade(self, trade_data: dict):
"""Process individual trade data"""
try:
symbol = trade_data['s']
# Excluded symbols kontrolü
if symbol in self.excluded_symbols:
return
price = float(trade_data['p'])
quantity = float(trade_data['q'])
# UTC zamanını kullan (borsanın event time'ı)
trade_time_utc = datetime.utcfromtimestamp(trade_data['T'] / 1000)
is_buyer_maker = trade_data['m'] # True = Sell order, False = Buy order
trade_direction = "SELL" if is_buyer_maker else "BUY"
# Trade value hesapla
trade_value = price * quantity
# Minimum trade value kontrolü
if trade_value < self.min_trade_value:
return
# Check if we have volume data for this symbol
if symbol in self.symbol_volumes:
volume_24h = self.symbol_volumes[symbol]
impact = self.calculate_trade_impact(price, quantity, volume_24h)
logger.info(f"🔥 LARGE TRADE DETECTED:")
logger.info(f" Symbol: {symbol}")
logger.info(f" Direction: {trade_direction}")
logger.info(f" Price: ${price:,.4f}")
logger.info(f" Quantity: {quantity:,.4f}")
logger.info(f" Trade Value: ${trade_value:,.2f}")
logger.info(f" 24h Volume: ${volume_24h:,.2f}")
logger.info(f" Volume Impact: {impact:.6f}%")
logger.info(f" Time (UTC): {trade_time_utc}")
logger.info("-" * 50)
else:
# Store trade for later processing when volume data arrives
self.pending_trades[symbol].append({
'price': price,
'quantity': quantity,
'time': trade_time_utc,
'direction': trade_direction,
'trade_value': trade_value
})
except Exception as e:
logger.error(f"Error processing trade: {e}")
def process_ticker(self, ticker_data: dict):
"""Process ticker data (24h volume)"""
try:
symbol = ticker_data['s']
# Excluded symbols kontrolü - ticker verilerini de kaydetme
if symbol in self.excluded_symbols:
return
volume_24h = float(ticker_data['v']) * float(ticker_data['c']) # volume * current price
# Update volume data
self.symbol_volumes[symbol] = volume_24h
# Add to volume history deque
self.volume_history[symbol].append({
'volume': volume_24h,
'timestamp': datetime.now()
})
# Process any pending trades for this symbol
if symbol in self.pending_trades and self.pending_trades[symbol]:
for trade in self.pending_trades[symbol]:
# Minimum trade value kontrolü
if trade['trade_value'] >= self.min_trade_value:
impact = self.calculate_trade_impact(
trade['price'],
trade['quantity'],
volume_24h
)
logger.info(f"🔥 LARGE TRADE DETECTED (from backlog):")
logger.info(f" Symbol: {symbol}")
logger.info(f" Direction: {trade['direction']}")
logger.info(f" Price: ${trade['price']:,.4f}")
logger.info(f" Quantity: {trade['quantity']:,.4f}")
logger.info(f" Trade Value: ${trade['trade_value']:,.2f}")
logger.info(f" 24h Volume: ${volume_24h:,.2f}")
logger.info(f" Volume Impact: {impact:.6f}%")
logger.info(f" Time (UTC): {trade['time']}")
logger.info("-" * 50)
# Clear processed trades
self.pending_trades[symbol] = []
except Exception as e:
logger.error(f"Error processing ticker: {e}")
async def subscribe_to_trades(self, websocket, symbols):
"""Subscribe to individual symbol trades"""
try:
# Excluded symbols'ı çıkar
filtered_symbols = [s for s in symbols if s not in self.excluded_symbols]
# Her sembol için trade stream'i ekle
trade_streams = [f"{symbol.lower()}@aggTrade" for symbol in filtered_symbols]
# Batch'ler halinde subscribe ol (WebSocket limitleri için)
batch_size = 100
for i in range(0, len(trade_streams), batch_size):
batch = trade_streams[i:i + batch_size]
subscribe_message = {
"method": "SUBSCRIBE",
"params": batch,
"id": i // batch_size + 2 # ID'leri farklı yap
}
await websocket.send(json.dumps(subscribe_message))
logger.info(f"Subscribed to {len(batch)} trade streams (batch {i//batch_size + 1})")
await asyncio.sleep(0.1) # Rate limiting için bekle
except Exception as e:
logger.error(f"Error subscribing to trades: {e}")
async def handle_message(self, message: str):
"""Handle incoming WebSocket messages"""
try:
data = json.loads(message)
if isinstance(data, dict):
if 'result' in data:
pass # Subscription result - no logging
elif 'error' in data:
logger.error(f"WebSocket error: {data['error']}")
if isinstance(data, list):
# Multiple messages in array
for item in data:
await self.process_single_message(item)
else:
# Single message
await self.process_single_message(data)
except json.JSONDecodeError as e:
logger.error(f"JSON decode error: {e}")
except Exception as e:
logger.error(f"Error handling message: {e}")
async def process_single_message(self, data: dict):
"""Process a single message"""
try:
stream = data.get('stream', '')
msg_data = data.get('data', {})
if '@aggTrade' in stream:
# Individual symbol trade data
self.process_trade(msg_data)
elif stream == '!ticker@arr':
# All tickers array data
if isinstance(msg_data, list):
for ticker in msg_data:
self.process_ticker(ticker)
else:
self.process_ticker(msg_data)
except Exception as e:
logger.error(f"Error processing single message: {e}")
async def run(self):
"""Main run method"""
logger.info(f"Starting Binance Futures Trade Impact Monitor")
logger.info(f"Minimum trade value threshold: ${self.min_trade_value:,.2f}")
max_retries = 5
retry_count = 0
while retry_count < max_retries:
try:
# WebSocket URL'sini düzelt
ws_url = "wss://fstream.binance.com/stream"
# Connect to WebSocket
async with websockets.connect(ws_url) as websocket:
logger.info("Connected to Binance WebSocket")
# İlk önce ticker stream'ine subscribe ol
ticker_subscribe_message = {
"method": "SUBSCRIBE",
"params": ["!ticker@arr"],
"id": 1
}
await websocket.send(json.dumps(ticker_subscribe_message))
logger.info("Subscribed to !ticker@arr stream")
# İlk ticker mesajını bekle ve sembol listesini al
symbols = set()
symbol_count_target = 100 # İlk 100 sembolü al
logger.info("Waiting for ticker data to get symbol list...")
async for message in websocket:
try:
data = json.loads(message)
# Ticker verisi geldiğinde sembolleri topla
if isinstance(data, dict) and data.get('stream') == '!ticker@arr':
ticker_data = data.get('data', [])
if isinstance(ticker_data, list):
for ticker in ticker_data:
symbol = ticker.get('s')
# Excluded symbols'ı atlayarak sembol topla
if symbol and symbol not in self.excluded_symbols and len(symbols) < symbol_count_target:
symbols.add(symbol)
# Hacim verisini de işle
self.process_ticker(ticker)
if len(symbols) >= symbol_count_target:
logger.info(f"Collected {len(symbols)} symbols, subscribing to trades...")
# Şimdi trade stream'lerine subscribe ol
await self.subscribe_to_trades(websocket, symbols)
break
except Exception as e:
logger.error(f"Error collecting symbols: {e}")
continue
# Ana mesaj döngüsü
logger.info("Starting main message loop...")
async for message in websocket:
await self.handle_message(message)
except websockets.exceptions.ConnectionClosed:
retry_count += 1
logger.warning(f"Connection closed. Retrying... ({retry_count}/{max_retries})")
await asyncio.sleep(5)
except Exception as e:
retry_count += 1
logger.error(f"Connection error: {e}. Retrying... ({retry_count}/{max_retries})")
await asyncio.sleep(5)
logger.error("Max retries reached. Exiting.")
def get_symbol_volume_stats(self, symbol: str) -> dict:
"""Get volume statistics for a symbol"""
if symbol not in self.volume_history:
return {}
volumes = [entry['volume'] for entry in self.volume_history[symbol]]
if not volumes:
return {}
return {
'current': volumes[-1],
'avg': sum(volumes) / len(volumes),
'min': min(volumes),
'max': max(volumes),
'count': len(volumes)
}
def print_stats(self):
"""Print current statistics"""
# Excluded symbols'ı çıkararak toplam sayıyı hesapla
monitored_count = len([s for s in self.symbol_volumes.keys() if s not in self.excluded_symbols])
logger.info(f"Monitoring {monitored_count} symbols")
# Top 10 symbols by volume (excluded symbols hariç)
filtered_symbols = {k: v for k, v in self.symbol_volumes.items() if k not in self.excluded_symbols}
top_symbols = sorted(filtered_symbols.items(), key=lambda x: x[1], reverse=True)[:10]
logger.info("Top 10 symbols by 24h volume:")
for symbol, volume in top_symbols:
logger.info(f" {symbol}: ${volume:,.2f}")
if self.excluded_symbols:
logger.info(f"Excluded symbols: {', '.join(self.excluded_symbols)}")
# Kullanım örneği
async def main():
# Excluded symbols listesi - bunlar izlenmeyecek ve çıktı verilmeyecek
excluded_symbols = ['ETHUSDT', 'BTCUSDT','ETHUSDC','BTCUSDC','SOLUSDT','XRPUSDT','DOGEUSDT','SOLUSDC']
# 20,000 USD'dan büyük işlemleri göster
monitor = BinanceTradeMonitor(
min_trade_value=40000.0,
excluded_symbols=excluded_symbols
)
# İstatistikleri göstermek için periyodik task
async def print_stats_periodically():
while True:
await asyncio.sleep(300) # 5 dakikada bir
monitor.print_stats()
# Her iki task'ı paralel çalıştır
await asyncio.gather(
monitor.run(),
print_stats_periodically()
)
if __name__ == "__main__":
try:
asyncio.run(main())
except KeyboardInterrupt:
logger.info("Program stopped by user")
except Exception as e:
logger.error(f"Unexpected error: {e}") 
