Python ile Binance API'si Nasıl Kullanılır

Binance API'ye Giriş

Binance API, geliştiricilere Binance'in alım satım platformuna programlı erişim sağlayarak, alım satım botları, uygulamalar ve takas ile etkileşim kuran araçlar oluşturmalarına olanak tanır. Bu eğitim, kimlik doğrulama kurulumundan çeşitli istek türleri yapmaya kadar, Binance API'sini kullanma sürecinde size rehberlik edecektir.

Birçok geliştirici geleneksel olarak API testleri için Postman'e güvenmiş olsa da, Apidog, Binance gibi kripto para birimi API'leriyle çalışmak için daha akıcı ve özel bir deneyim sunar. Sezgisel arayüzü, gelişmiş kimlik doğrulama yönetimi ve yerleşik kripto özellikleriyle, Apidog, Binance API uç noktalarını test etmeye ve uygulamaya başlamak için gereken kurulum süresini önemli ölçüde azaltır.

button

Platformun gerçek zamanlı işbirliği araçları ve kapsamlı dokümantasyon oluşturma yetenekleri, onu özellikle kripto alım satım uygulamaları üzerinde çalışan ekipler için değerli kılar.

Verimli Binance API entegrasyonu konusunda ciddiyseniz, Apidog'a geçiş, geliştirme iş akışınızı önemli ölçüde iyileştirecek ve kripto projeleriniz için dağıtım süresini azaltacaktır.

button

Binance API Kimlik Doğrulamasını Kurma

Binance API'sini kullanmadan önce, Binance hesabınızdan API anahtarları oluşturmanız gerekir. Bu bölüm, API anahtarlarınızı nasıl kuracağınızı ve güvence altına alacağınızı ele almaktadır.

Binance API Anahtarları Oluşturma

Binance hesabınıza giriş yapın
Hesap ayarlarınızda "API Yönetimi"ne gidin
Yeni bir API anahtarı oluşturun
API anahtarınızı ve gizli anahtarınızı not edin
Kısıtlamaları yapılandırın (IP beyaz listeye alma, alım satım izinleri vb.)

Binance API Tarafından Desteklenen API Anahtarı Türleri

Binance, üç tür API anahtarı kimlik doğrulama yöntemini destekler:

HMAC Anahtarları - En yaygın kimlik doğrulama yöntemi
RSA Anahtarları - Gelişmiş güvenlik özellikleri sunar
Ed25519 Anahtarları - En iyi performansı ve güvenliği sağlar

HMAC Kimlik Doğrulama Örneği

HMAC anahtarlarıyla nasıl kimlik doğrulaması yapacağınız aşağıdadır:

import hmac
import hashlib
import time
import requests
from urllib.parse import urlencode

# API kimlik bilgileri
api_key = 'your_api_key'
api_secret = 'your_api_secret'

# Binance API için temel URL
base_url = '<https://api.binance.com>'

# Kimliği doğrulanmış uç noktalar için bir imza oluşturma işlevi
def get_signature(query_string):
    return hmac.new(
        api_secret.encode('utf-8'),
        query_string.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()

# Hesap bilgilerini almak için örnek istek
def get_account():
    endpoint = '/api/v3/account'
    timestamp = int(time.time() * 1000)

    params = {
        'timestamp': timestamp,
        'recvWindow': 5000  # İsteğe bağlı parametre
    }

    query_string = urlencode(params)
    signature = get_signature(query_string)

    url = f"{base_url}{endpoint}?{query_string}&signature={signature}"

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.get(url, headers=headers)
    return response.json()

# İşlevi çağırın
account_info = get_account()
print(account_info)

Binance API Uç Noktalarını Anlama

Binance API, işlevlerine göre çeşitli uç nokta kategorilerine ayrılmıştır.

Genel Binance API Uç Noktaları

Bu uç noktalar, takas hakkında genel bilgiler sağlar:

# Bağlantıyı test et
def test_connectivity():
    endpoint = '/api/v3/ping'
    url = f"{base_url}{endpoint}"
    response = requests.get(url)
    return response.json()

# Sunucu zamanını al
def get_server_time():
    endpoint = '/api/v3/time'
    url = f"{base_url}{endpoint}"
    response = requests.get(url)
    return response.json()

# Takas bilgilerini al
def get_exchange_info():
    endpoint = '/api/v3/exchangeInfo'
    url = f"{base_url}{endpoint}"
    response = requests.get(url)
    return response.json()

Piyasa Verileri Binance API Uç Noktaları

Bu uç noktalar, piyasa verilerine erişim sağlar:

# Bir sembol için emir defterini al
def get_order_book(symbol, limit=100):
    endpoint = '/api/v3/depth'
    params = {
        'symbol': symbol,
        'limit': limit
    }
    url = f"{base_url}{endpoint}?{urlencode(params)}"
    response = requests.get(url)
    return response.json()

# Son işlemleri al
def get_recent_trades(symbol, limit=500):
    endpoint = '/api/v3/trades'
    params = {
        'symbol': symbol,
        'limit': limit
    }
    url = f"{base_url}{endpoint}?{urlencode(params)}"
    response = requests.get(url)
    return response.json()

# Mum grafiği verilerini al
def get_klines(symbol, interval, start_time=None, end_time=None, limit=500):
    endpoint = '/api/v3/klines'
    params = {
        'symbol': symbol,
        'interval': interval,
        'limit': limit
    }

    if start_time:
        params['startTime'] = start_time
    if end_time:
        params['endTime'] = end_time

    url = f"{base_url}{endpoint}?{urlencode(params)}"
    response = requests.get(url)

    # Yanıtı biçimlendir
    klines = response.json()
    formatted_klines = []
    for k in klines:
        formatted_klines.append({
            'open_time': k[0],
            'open': float(k[1]),
            'high': float(k[2]),
            'low': float(k[3]),
            'close': float(k[4]),
            'volume': float(k[5]),
            'close_time': k[6],
            'quote_volume': float(k[7]),
            'trades': k[8],
            'taker_buy_base_volume': float(k[9]),
            'taker_buy_quote_volume': float(k[10])
        })

    return formatted_klines

Binance API ile Alım Satım

Alım satım uç noktaları, emir vermenize ve yönetmenize olanak tanır.

Binance API ile Emir Verme

Farklı türde emirlerin nasıl verileceği aşağıdadır:

# LİMİT emri ver
def place_limit_order(symbol, side, quantity, price):
    endpoint = '/api/v3/order'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'side': side,  # 'BUY' veya 'SELL'
        'type': 'LIMIT',
        'timeInForce': 'GTC',  # İptal Edilene Kadar Geçerli
        'quantity': quantity,
        'price': price,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    query_string = urlencode(params)
    signature = get_signature(query_string)

    url = f"{base_url}{endpoint}?{query_string}&signature={signature}"

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.post(url, headers=headers)
    return response.json()

# PİYASA emri ver
def place_market_order(symbol, side, quantity):
    endpoint = '/api/v3/order'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'side': side,  # 'BUY' veya 'SELL'
        'type': 'MARKET',
        'quantity': quantity,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    query_string = urlencode(params)
    signature = get_signature(query_string)

    url = f"{base_url}{endpoint}?{query_string}&signature={signature}"

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.post(url, headers=headers)
    return response.json()

# STOP_LOSS emri ver
def place_stop_loss_order(symbol, side, quantity, stop_price):
    endpoint = '/api/v3/order'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'side': side,
        'type': 'STOP_LOSS',
        'quantity': quantity,
        'stopPrice': stop_price,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    query_string = urlencode(params)
    signature = get_signature(query_string)

    url = f"{base_url}{endpoint}?{query_string}&signature={signature}"

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.post(url, headers=headers)
    return response.json()

Binance API ile Emirleri Yönetme

Emirleri nasıl sorgulayacağınız, iptal edeceğiniz ve takip edeceğiniz aşağıdadır:

# Emir durumunu sorgula
def query_order(symbol, order_id=None, orig_client_order_id=None):
    endpoint = '/api/v3/order'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    if order_id:
        params['orderId'] = order_id
    elif orig_client_order_id:
        params['origClientOrderId'] = orig_client_order_id
    else:
        raise ValueError("order_id veya orig_client_order_id sağlanmalıdır")

    query_string = urlencode(params)
    signature = get_signature(query_string)

    url = f"{base_url}{endpoint}?{query_string}&signature={signature}"

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.get(url, headers=headers)
    return response.json()

# Bir emri iptal et
def cancel_order(symbol, order_id=None, orig_client_order_id=None):
    endpoint = '/api/v3/order'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    if order_id:
        params['orderId'] = order_id
    elif orig_client_order_id:
        params['origClientOrderId'] = orig_client_order_id
    else:
        raise ValueError("order_id veya orig_client_order_id sağlanmalıdır")

    query_string = urlencode(params)
    signature = get_signature(query_string)

    url = f"{base_url}{endpoint}?{query_string}&signature={signature}"

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.delete(url, headers=headers)
    return response.json()

# Tüm açık emirleri al
def get_open_orders(symbol=None):
    endpoint = '/api/v3/openOrders'
    timestamp = int(time.time() * 1000)

    params = {
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    if symbol:
        params['symbol'] = symbol

    query_string = urlencode(params)
    signature = get_signature(query_string)

    url = f"{base_url}{endpoint}?{query_string}&signature={signature}"

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.get(url, headers=headers)
    return response.json()

Binance API ile Hesap ve Kullanıcı Verileri

Bu uç noktalar, hesap bilgilerinize erişmenize ve kullanıcı verilerini yayınlamanıza olanak tanır.

Binance API ile Hesap Bilgileri

# Hesap bilgilerini al
def get_account_information():
    endpoint = '/api/v3/account'
    timestamp = int(time.time() * 1000)

    params = {
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    query_string = urlencode(params)
    signature = get_signature(query_string)

    url = f"{base_url}{endpoint}?{query_string}&signature={signature}"

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.get(url, headers=headers)
    return response.json()

# Hesap işlem listesini al
def get_account_trades(symbol, start_time=None, end_time=None, limit=500):
    endpoint = '/api/v3/myTrades'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'timestamp': timestamp,
        'limit': limit,
        'recvWindow': 5000
    }

    if start_time:
        params['startTime'] = start_time
    if end_time:
        params['endTime'] = end_time

    query_string = urlencode(params)
    signature = get_signature(query_string)

    url = f"{base_url}{endpoint}?{query_string}&signature={signature}"

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.get(url, headers=headers)
    return response.json()

Binance API ile Kullanıcı Veri Akışları

# Bir kullanıcı veri akışı başlat
def start_user_data_stream():
    endpoint = '/api/v3/userDataStream'

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.post(f"{base_url}{endpoint}", headers=headers)
    return response.json()

# Bir kullanıcı veri akışını canlı tut
def keep_alive_user_data_stream(listen_key):
    endpoint = '/api/v3/userDataStream'

    params = {
        'listenKey': listen_key
    }

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.put(f"{base_url}{endpoint}?{urlencode(params)}", headers=headers)
    return response.json()

# Bir kullanıcı veri akışını kapat
def close_user_data_stream(listen_key):
    endpoint = '/api/v3/userDataStream'

    params = {
        'listenKey': listen_key
    }

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.delete(f"{base_url}{endpoint}?{urlencode(params)}", headers=headers)
    return response.json()

Gelişmiş Binance API Özellikleri

Bu bölüm, Binance API'sinin daha gelişmiş özelliklerinden bazılarını ele almaktadır.

Binance API'de Emir Listeleri (OCO) ile Çalışma

Birbiri İptal Eder (OCO) emirleri, birinin tetiklenmesi durumunda diğerinin otomatik olarak iptal edildiği bir çift emir vermenize olanak tanır:

# Bir OCO emri ver
def place_oco_order(symbol, side, quantity, price, stop_price):
    endpoint = '/api/v3/orderList/oco'
    timestamp = int(time.time() * 1000)

    params = {
        'symbol': symbol,
        'side': side,
        'quantity': quantity,
        'price': price,
        'stopPrice': stop_price,
        'timestamp': timestamp,
        'recvWindow': 5000
    }

    # OCO emri için türleri tarafa göre tanımlayın
    if side == 'SELL':
        params['aboveType'] = 'STOP_LOSS'
        params['belowType'] = 'LIMIT_MAKER'
    else:
        params['aboveType'] = 'LIMIT_MAKER'
        params['belowType'] = 'STOP_LOSS'

    params['aboveTimeInForce'] = 'GTC'
    params['belowTimeInForce'] = 'GTC'

    query_string = urlencode(params)
    signature = get_signature(query_string)

    url = f"{base_url}{endpoint}?{query_string}&signature={signature}"

    headers = {
        'X-MBX-APIKEY': api_key
    }

    response = requests.post(url, headers=headers)
    return response.json()

Binance API'de Oran Sınırlarını İşleme

Binance, API isteklerine oran sınırları uygular. Bunları nasıl ele alacağınız aşağıdadır:

import time
from functools import wraps

# Oran sınırlarını işlemek için dekoratör
def handle_rate_limit(max_retries=3, retry_delay=30):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            retries = 0
            while retries <= max_retries:
                try:
                    response = func(*args, **kwargs)
                    if 'code' in response and response['code'] == -1429:  # Oran sınırı aşıldı
                        retries += 1
                        if retries > max_retries:
                            raise Exception(f"Oran sınırı {max_retries} denemeden sonra aşıldı")
                        print(f"Oran sınırı aşıldı. Yeniden denemeden önce {retry_delay} saniye bekleniyor...")
                        time.sleep(retry_delay)
                    else:
                        return response
                except Exception as e:
                    if "429" in str(e) or "418" in str(e):
                        retries += 1
                        if retries > max_retries:
                            raise
                        print(f"Oran sınırı aşıldı. Yeniden denemeden önce {retry_delay} saniye bekleniyor...")
                        time.sleep(retry_delay)
                    else:
                        raise
        return wrapper
    return decorator

# Örnek kullanım
@handle_rate_limit()
def get_exchange_info_with_retry():
    endpoint = '/api/v3/exchangeInfo'
    url = f"{base_url}{endpoint}"
    response = requests.get(url)
    return response.json()

Tam Bir Binance API Alım Satım Botu Oluşturma

Şimdi basit bir alım satım botu oluşturmak için her şeyi bir araya getirelim:

import hmac
import hashlib
import time
import requests
import json
import websocket
import threading
from urllib.parse import urlencode

class BinanceTrader:
    def __init__(self, api_key, api_secret, symbol='BTCUSDT'):
        self.api_key = api_key
        self.api_secret = api_secret
        self.base_url = '<https://api.binance.com>'
        self.symbol = symbol
        self.ws = None
        self.listen_key = None
        self.keep_alive_thread = None

    def get_signature(self, query_string):
        return hmac.new(
            self.api_secret.encode('utf-8'),
            query_string.encode('utf-8'),
            hashlib.sha256
        ).hexdigest()

    def get_server_time(self):
        endpoint = '/api/v3/time'
        response = requests.get(f"{self.base_url}{endpoint}")
        return response.json()['serverTime']

    def get_account_info(self):
        endpoint = '/api/v3/account'
        timestamp = int(time.time() * 1000)

        params = {
            'timestamp': timestamp,
            'recvWindow': 5000
        }

        query_string = urlencode(params)
        signature = self.get_signature(query_string)

        url = f"{self.base_url}{endpoint}?{query_string}&signature={signature}"

        headers = {
            'X-MBX-APIKEY': self.api_key
        }

        response = requests.get(url, headers=headers)
        return response.json()

    def place_market_order(self, side, quantity):
        endpoint = '/api/v3/order'
        timestamp = int(time.time() * 1000)

        params = {
            'symbol': self.symbol,
            'side': side,
            'type': 'MARKET',
            'quantity': quantity,
            'timestamp': timestamp,
            'recvWindow': 5000
        }

        query_string = urlencode(params)
        signature = self.get_signature(query_string)

        url = f"{self.base_url}{endpoint}?{query_string}&signature={signature}"

        headers = {
            'X-MBX-APIKEY': self.api_key
        }

        response = requests.post(url, headers=headers)
        return response.json()

    def start_user_data_stream(self):
        endpoint = '/api/v3/userDataStream'

        headers = {
            'X-MBX-APIKEY': self.api_key
        }

        response = requests.post(f"{self.base_url}{endpoint}", headers=headers)
        self.listen_key = response.json()['listenKey']
        return self.listen_key

    def keep_alive_user_data_stream(self):
        while True:
            if self.listen_key:
                endpoint = '/api/v3/userDataStream'

                params = {
                    'listenKey': self.listen_key
                }

                headers = {
                    'X-MBX-APIKEY': self.api_key
                }

                requests.put(f"{self.base_url}{endpoint}?{urlencode(params)}", headers=headers)
            time.sleep(30 * 60)  # Her 30 dakikada bir canlı tut

    def on_message(self, ws, message):
        data = json.loads(message)

        # Hesap güncellemelerini işle
        if data.get('e') == 'outboundAccountPosition':
            print("Hesap güncellemesi alındı:")
            print(f"Güncelleme zamanı: {data['u']}")
            print("Bakiyeler:")
            for balance in data['B']:
                print(f"Varlık: {balance['a']}, Serbest: {balance['f']}, Kilitli: {balance['l']}")

        # Emir güncellemelerini işle
        elif data.get('e') == 'executionReport':
            print("Emir güncellemesi alındı:")
            print(f"Sembol: {data['s']}")
            print(f"Taraf: {data['S']}")
            print(f"Emir türü: {data['o']}")
            print(f"Emir durumu: {data['X']}")
            print(f"Fiyat: {data['p']}")
            print(f"Miktar: {data['q']}")
            print(f"Gerçekleştirilen miktar: {data['z']}")

            # Emir güncellemelerine göre alım satım mantığını burada uygulayın
            if data['X'] == 'FILLED' and data['S'] == 'BUY':
                # Örnek: Alım dolduğunda bir satış emri verin
                sell_price = float(data['p']) * 1.05  # %5 kar hedefi
                self.place_limit_order('SELL', data['q'], sell_price)

    def on_error(self, ws, error):
        print(f"Hata: {error}")

    def on_close(self, ws, close_status_code, close_msg):
        print("WebSocket bağlantısı kapatıldı")

    def on_open(self, ws):
        print("WebSocket bağlantısı açıldı")

    def start_websocket(self):
        self.start_user_data_stream()
        socket_url = f"wss://stream.binance.com:9443/ws/{self.listen_key}"

        self.ws = websocket.WebSocketApp(
            socket_url,
            on_message=self.on_message,
            on_error=self.on_error,
            on_close=self.on_close,
            on_open=self.on_open
        )

        # Canlı tutma iş parçacığını başlat
        self.keep_alive_thread = threading.Thread(target=self.keep_alive_user_data_stream)
        self.keep_alive_thread.daemon = True
        self.keep_alive_thread.start()

        # WebSocket'i ayrı bir iş parçacığında çalıştırın
        ws_thread = threading.Thread(target=self.ws.run_forever)
        ws_thread.daemon = True
        ws_thread.start()

        return ws_thread

# Örnek kullanım
if __name__ == "__main__":
    api_key = "your_api_key"
    api_secret = "your_api_secret"

    trader = BinanceTrader(api_key, api_secret, 'BTCUSDT')

    # Hesap bilgilerini al
    account_info = trader.get_account_info()
    print("Hesap Bilgileri:")
    print(f"Alım Satım Yapabilir: {account_info['canTrade']}")
    print(f"Para Çekebilir: {account_info['canWithdraw']}")
    print(f"Para Yatırabilir: {account_info['canDeposit']}")

    # Bakiyeleri yazdır
    print("\\\\nBakiyeler:")
    for balance in account_info['balances']:
        if float(balance['free']) > 0 or float(balance['locked']) > 0:
            print(f"Varlık: {balance['asset']}, Serbest: {balance['free']}, Kilitli: {balance['locked']}")

    # Gerçek zamanlı güncellemeler için WebSocket'i başlat
    ws_thread = trader.start_websocket()

    try:
        # Ana iş parçacığını çalışır durumda tut
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print("Duruyor...")
        trader.ws.close()

Binance API'sini Kullanmak İçin En İyi Uygulamalar

Binance API'si ile çalışırken izlenecek bazı en iyi uygulamalar şunlardır:

Binance API için Güvenlik Uygulamaları

API Anahtarı İzinlerini Kısıtla: Yalnızca ihtiyacınız olan izinleri etkinleştirin (örneğin, salt okunur, alım satım, para çekme)
IP Adreslerini Beyaz Listeye Al: API anahtarlarınızı yalnızca belirli IP adreslerinden çalışacak şekilde kısıtlayın
Güvenli API Anahtarı Depolama: API anahtarlarını asla kodunuza doğrudan yazmayın, ortam değişkenlerini veya güvenli kasaları kullanın
Düzenli Anahtar Döndürme: Riski azaltmak için API anahtarlarınızı periyodik olarak değiştirin

import os

# API anahtarlarını ortam değişkenlerinden yükle
api_key = os.environ.get('BINANCE_API_KEY')
api_secret = os.environ.get('BINANCE_API_SECRET')

if not api_key or not api_secret:
    raise ValueError("API anahtarları ortam değişkenlerinde bulunamadı")

Binance API ile Hata İşleme

API hataları ve bağlantı sorunlarıyla başa çıkmak için sağlam hata işleme uygulayın:

def safe_request(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        try:
            response = func(*args, **kwargs)
            # API hata kodlarını kontrol et
            if isinstance(response, dict) and 'code' in response:
                print(f"API Hatası: Kod {response['code']}, İleti: {response.get('msg', 'İleti yok')}")
                # Belirli hata kodlarını işleyin
                if response['code'] == -1021:  # INVALID_TIMESTAMP
                    print("Sunucu ve yerel zaman senkronize değil. Zaman damgası ayarlanıyor...")
                    # Zaman damgası ayarlama mantığını burada uygulayın
                elif response['code'] == -2010:  # INSUFFICIENT_BALANCE
                    print("Emir için yetersiz bakiye.")
                # Gerektiğinde daha özel hata işleme ekleyin
            return response
        except requests.exceptions.RequestException as e:
            print(f"İstek Hatası: {e}")
            # Yeniden deneme mantığını veya yedek davranışı uygulayın
            return None
        except json.JSONDecodeError:
            print("JSON yanıtı çözülemedi")
            return None
        except Exception as e:
            print(f"Beklenmedik hata: {e}")
            return None
    return wrapper

@safe_request
def get_account_info_safe():
    # Düzgün hata işlemesi ile get_account_info'nun uygulanması
    # ...

Sonuç

Binance API, Binance takasıyla programlı olarak etkileşim kurmanın güçlü bir yolunu sunar. Bu eğitim, kimlik doğrulamadan emir vermeye ve hesabınızı yönetmeye kadar API'yi kullanmanın temel yönlerini ele almıştır. En iyi uygulamaları izleyerek ve uygun hata işlemesi uygulayarak, Binance'in kapsamlı özellik setinden yararlanan sağlam uygulamalar ve alım satım botları oluşturabilirsiniz.

API