Profit Like a Pro: Uncovering Hidden Opportunities with Cross-Market Arbitrage using Python & Websocket

Have you ever wondered if it’s possible to make a profit by buying low on one exchange and selling high on another? This is called cross market arbitrage, and it’s a popular trading strategy among investors.

In this blog post, we will explore how to detect cross market arbitrages between Binance and Bybit spot prices for the AVAXUSDT trading pair using Python and Websocket API. We will also write a function that sends orders to both exchanges.

What is Cross Market Arbitrage?

Cross market arbitrage is a trading strategy that involves buying assets on one exchange where the price is lower and simultaneously selling the same assets on another exchange where the price is higher. The price difference between the two exchanges can be exploited for profit by taking advantage of the price discrepancy.

Connecting to Binance and Bybit Websocket API

To connect to Binance and Bybit Websocket API, we will use Python and the websocket library. Here's how to get started:

import websocket
import json

def on_message(ws, message):
    data = json.loads(message)
    # Parse data to extract AVAXUSDT spot prices
    # Compare spot prices and execute orders if profitable
def on_error(ws, error):
    print(error)
def on_close(ws):
    print("Connection closed")
def on_open(ws):
    # Start subscribing to AVAXUSDT ticker data
    ws.send('{"method": "SUBSCRIBE", "params": ["avaxusdt@ticker"], "id": 1}')
if __name__ == "__main__":
    # Connect to Binance and Bybit Websocket API
    binance_ws = websocket.WebSocketApp("wss://stream.binance.com:9443/ws/avaxusdt@ticker", on_message=on_message, on_error=on_error, on_close=on_close)
    bybit_ws = websocket.WebSocketApp("wss://stream.bybit.com/realtime_public?subscribe=instrument_info.1000ms.AVAXUSDT", on_message=on_message, on_error=on_error, on_close=on_close)
    # Start listening to Websocket API
    binance_ws.on_open = on_open
    bybit_ws.on_open = on_open
    binance_ws.run_forever()
    bybit_ws.run_forever()

Sending Orders to Binance and Bybit

To send orders to Binance and Bybit, we will use the REST API and send authenticated requests. Here’s an example function that sends a buy order to Binance:

import requests
import hashlib
import hmac
import time

def send_order_binance(api_key, secret_key, symbol, side, quantity, price):
    # Define request parameters
    timestamp = int(time.time() * 1000)
    base_url = "<https://api.binance.com>"
    endpoint = "/api/v3/order"
    params = {
        "symbol": symbol,
        "side": side,
        "type": "LIMIT",
        "timeInForce": "GTC",
        "quantity": quantity,
        "price": price,
        "recvWindow": 5000,
        "timestamp": timestamp
    }
    # Create signature
    query_string = "&".join([f"{k}={v}" for k, v in params.items()])
    signature = hmac.new(secret_key.encode(), query_string.encode(), hashlib.sha256).hexdigest()
    # Send authenticated request
    headers = {
        "X-MBX-APIKEY": api_key
    }
    url = f"{base_url}{endpoint}?{query_string}&signature={signature}"
    response = requests.post(url, headers=headers)
    return response.json()
def send_order_bybit(api_key, secret_key, symbol, side, quantity, price):
    # Define request parameters
    timestamp = int(time.time() * 1000)
    base_url = "<https://api.bybit.com>"
    endpoint = "/v2/private/order/create"
    params = {
        "symbol": symbol,
        "side": side.lower(),
        "order_type": "Limit",
        "qty": quantity,
        "price": price,
        "time_in_force": "GoodTillCancel",
        "timestamp": timestamp
    }
    # Create signature
    query_string = "&".join([f"{k}={v}" for k, v in params.items()])
    signature = hmac.new(secret_key.encode(), query_string.encode(), hashlib.sha256).hexdigest()
    # Send authenticated request
    headers = {
        "api-key": api_key,
        "sign": signature,
        "Content-Type": "application/json"
    }
    url = f"{base_url}{endpoint}"
    response = requests.post(url, headers=headers, data=json.dumps(params))
    return response.json()

Detecting Cross Market Arbitrages

To detect cross market arbitrages between Binance and Bybit, we will use Python and Websocket API. Here are the steps involved:

1. Connect to Binance and Bybit Websocket API to receive real-time market data for the AVAXUSDT trading pair.
2. Parse the market data to extract the spot prices of AVAXUSDT on both exchanges.
3. Compare the spot prices of AVAXUSDT on both exchanges.
4. If the price difference is significant enough to cover trading fees, execute a buy order on Binance and a sell order on Bybit using the send_order_binance and send_order_bybit functions, respectively.
5. Monitor the market data continuously to detect new arbitrage opportunities.

Here’s an example implementation of step 3 and 4:

binance_price = 0
bybit_price = 0

def on_message(ws, message):
    global binance_price, bybit_price
    data = json.loads(message)
    if 'binance' in data['stream']:
        binance_price = float(data['data']['p'])
    elif 'bybit' in data['topic']:
        bybit_price = float(data['data'][0]['last_price'])
    if binance_price and bybit_price:
        # Calculate price difference and trading fees
        price_diff = bybit_price - binance_price
        binance_fee_rate = 0.001
        bybit_fee_rate = 0.00075
        min_profit = 0.0001
        # Check if profitable arbitrage opportunity exists
        if price_diff > (binance_fee_rate + bybit_fee_rate + min_profit):
            # Execute orders
            binance_api_key = "<BINANCE_API_KEY>"
            binance_secret_key = "<BINANCE_SECRET_KEY>"
            bybit_api_key = "<BYBIT_API_KEY>"
            bybit_secret_key = "<BYBIT_SECRET_KEY>"
            symbol = "AVAXUSDT"
            quantity = 1
            binance_buy_price = binance_price
            bybit_sell_price = bybit_price
            send_order_binance(binance_api_key, binance_secret_key, symbol, "BUY", quantity, binance_buy_price)
            send_order_bybit(bybit_api_key, bybit_secret_key, symbol, "SELL", quantity, bybit_sell_price)
            print("Arbitrage executed!")
# Rest of the code

Conclusion

Cross market arbitrage can be a profitable trading strategy if executed correctly. By using Python and Websocket API to receive real-time market data from exchanges like Binance and Bybit, we can automate the process of detecting arbitrage opportunities and increase our chances of making a profit.

To get started with detecting cross market arbitrages, check out the Binance and Bybit API documentation and start experimenting with Python. Happy trading!