Python से ट्रेडिंग बॉट बनाएँ: Binance API.

क्रिप्टो की दुनिया में Binance की API सबसे पूरी और सबसे अच्छी तरह डॉक्यूमेंटेड APIs में से एक है, और उसे खंगालने के लिए Python सबसे सही भाषा है। इस ट्यूटोरियल में आप एक असली ट्रेडिंग बॉट की नींव बनाएँगे — कोई खिलौना नहीं। हम उन तीन चीज़ों को प्राथमिकता देंगे जो शौकिया कोड को सीरियस कोड से अलग करती हैं: API keys की सिक्योरिटी, ज़िम्मेदारियों का साफ़ बँटवारा और लाइव जाने से पहले टेस्टिंग.

01एनवायरनमेंट सेटअप

Python 3.11+, virtualenv और लाइब्रेरी। दो मुख्य विकल्प हैं: python-binance (Binance के लिए स्पेसिफिक, ज़्यादा सीधी) और ccxt (जेनेरिक, दर्जनों exchanges पर चलती है)। फोकस्ड शुरुआत के लिए हमारा चुनाव: python-binance.

# प्रोजेक्ट और isolated environment बनाएं
mkdir bot-binance && cd bot-binance
python -m venv venv
source venv/bin/activate  # Linux/Mac (Windows: venv\Scripts\activate)

pip install python-binance pandas python-dotenv

02API keys बनाना (सुरक्षित तरीके से)

अपने Binance अकाउंट में जाएँ — API Management — और एक key बनाएँ। सिक्योरिटी के सुनहरे नियम:

• कम से कम परमिशन: सिर्फ़ "Read" और "Spot Trading" ऑन करें। कभी भी "Withdraw" की परमिशन ऑन मत कीजिए।
• IP से रिस्ट्रिक्ट करें अगर फिक्स्ड IP वाले VPS पर चलाने वाले हैं।
• Secret Key तुरंत सेव कर लें — यह सिर्फ़ एक बार दिखती है।

keys को इस फ़ाइल में रखें: .env (और .env को डालिए इस फ़ाइल में: .gitignore):

# .env — इस file को कभी version control में न डालें
BINANCE_API_KEY=sua_chave_aqui
BINANCE_API_SECRET=seu_secret_aqui

03कनेक्ट करना और कैंडल्स खींचना

पहला संपर्क — testnet (डमी बैलेंस वाला टेस्ट एनवायरनमेंट) से कनेक्ट करके डेटा खींचना:

# conectar.py
import os
from binance.client import Client
from dotenv import load_dotenv
import pandas as pd

load_dotenv()
# testnet=True usa o ambiente de teste — comece SEMPRE aqui
client = Client(os.getenv("BINANCE_API_KEY"),
                os.getenv("BINANCE_API_SECRET"),
                testnet=True)

def get_candles(symbol="BTCUSDT", interval="15m", limit=100):
    raw = client.get_klines(symbol=symbol, interval=interval, limit=limit)
    df = pd.DataFrame(raw, columns=[
        "open_time","open","high","low","close","volume",
        "close_time","qav","trades","tbav","tqav","ignore"])
    df["close"] = df["close"].astype(float)
    return df

df = get_candles()
print(df[["close"]].tail())

04सिग्नल कैलकुलेट करना (स्ट्रैटेजी एक प्योर फंक्शन के रूप में)

यही वह सिद्धांत है जो प्रोफेशनल कोड को अलग करता है: स्ट्रैटेजी एक प्योर फंक्शन होती है — डेटा लेती है, सिग्नल लौटाती है, कोई साइड इफेक्ट नहीं। इससे उसे अलग से, बिना कहीं कनेक्ट किए टेस्ट किया जा सकता है। मूविंग एवरेज क्रॉसओवर + RSI का उदाहरण:

# strategy.py
import pandas as pd

def calcular_rsi(series, periodo=14):
    delta = series.diff()
    ganho = delta.clip(lower=0).rolling(periodo).mean()
    perda = -delta.clip(upper=0).rolling(periodo).mean()
    rs = ganho / perda
    return 100 - (100 / (1 + rs))

def calcular_sinal(df: pd.DataFrame) -> str:
    df["ma_rapida"] = df["close"].rolling(9).mean()
    df["ma_lenta"]  = df["close"].rolling(21).mean()
    df["rsi"] = calcular_rsi(df["close"])

    u = df.iloc[-1]
    # खरीद: अपट्रेंड + RSI overbought नहीं
    if u["ma_rapida"] > u["ma_lenta"] and u["rsi"] < 70:
        return "COMPRA"
    if u["ma_rapida"] < u["ma_lenta"] and u["rsi"] > 30:
        return "VENDA"
    return "AGUARDA"

05ऑर्डर एक्ज़ीक्यूट करना (पहले testnet पर!)

सिग्नल कैलकुलेट हो जाने के बाद एक्ज़ीक्यूशन लेयर ऑर्डर भेजती है। ध्यान दीजिए कि यह testnet पर चल रहा है — डमी बैलेंस:

# executor.py
from binance.enums import *

def executar_ordem(client, symbol, sinal, quantidade):
    if sinal == "COMPRA":
        ordem = client.create_order(
            symbol=symbol, side=SIDE_BUY,
            type=ORDER_TYPE_MARKET, quantity=quantidade)
        return ordem
    if sinal == "VENDA":
        ordem = client.create_order(
            symbol=symbol, side=SIDE_SELL,
            type=ORDER_TYPE_MARKET, quantity=quantidade)
        return ordem
    return None  # इंतज़ार: कुछ नहीं करता

06ऐसे बॉट की आर्किटेक्चर जो आपको कंगाल न करे

टुकड़ों को साफ़ अलगाव के साथ जोड़िए। सीरियस बॉट में एक-दूसरे से स्वतंत्र लेयर्स होती हैं:

# सुझाया गया structure
# ├── client.py     # Binance कनेक्शन + reconnect
# ├── strategy.py   # pure functions: डेटा → सिग्नल (testable)
# ├── risk.py       # position size, stop, take, लिमिट्स
# ├── executor.py   # ऑर्डर भेजता है, state संभालता है
# ├── logger.py     # सब कुछ log करता है (ऑडिट बहुत ज़रूरी)
# └── main.py       # मुख्य loop, सब जोड़ता है

# main.py — loop básico
import time

while True:
    try:
        df = get_candles()
        sinal = calcular_sinal(df)
        qtd = calcular_tamanho_posicao(saldo, risco_pct=1)  # risk.py से
        if sinal != "AGUARDA":
            executar_ordem(client, "BTCUSDT", sinal, qtd)
            log(sinal, qtd)
        time.sleep(60)  # हर मिनट चेक करता है
    except Exception as e:
        log_erro(e)
        time.sleep(30)  # loop को कभी चुपचाप बंद न होने दें

07कोड में रिस्क मैनेजमेंट

स्ट्रैटेजी तय करती है कि कब एंट्री लेनी है; रिस्क मैनेजमेंट तय करता है कि कितना। दूसरे के बिना पहले का कोई मतलब नहीं। risk.py में कम से कम इतना ज़रूर होना चाहिए:

• पोज़िशन साइज़ कैपिटल के % के हिसाब से (जैसे हर ट्रेड पर 1% रिस्क)।
• स्टॉप लॉस हर पोज़िशन पर अपने आप — कभी बिना स्टॉप के मत छोड़िए।
• डेली लॉस लिमिट जिस पर पहुँचते ही बॉट खुद बंद हो जाए।
• एक साथ खुली पोज़िशनों की अधिकतम संख्या ताकि रिस्क एक ही जगह जमा न हो।

08रियल से पहले testnet और बैकटेस्ट

असली पैसा लगाने से पहले यह क्रम ज़रूरी है: (1) बैकटेस्ट — स्ट्रैटेजी फंक्शन का, हिस्टोरिकल डेटा पर; (2) testnet — Binance की, हफ़्तों तक, असली मार्केट कंडीशन में डमी बैलेंस के साथ; (3) उसके बाद ही कम से कम रकम के साथ रियल अकाउंट। कोई भी स्टेप छोड़ना आँखें बंद करके गाड़ी चलाने जैसा है।

09अक्सर पूछे जाने वाले सवाल