Bot Integration with MEXC API

HTX API Bot Integration

HTX (formerly Huobi) — one of the largest Asian exchanges. API supports spot, margin, and futures. Key features: authentication via HMAC-SHA256, specific WebSocket message structure with gzip compression.

Connecting to HTX API

import ccxt

exchange = ccxt.htx({
    'apiKey': API_KEY,
    'secret': SECRET,
    'enableRateLimit': True,
})

# Get balance
balance = exchange.fetch_balance()
usdt_balance = balance['USDT']['free']

# Place order
order = exchange.create_order(
    symbol='BTC/USDT',
    type='limit',
    side='buy',
    amount=0.001,
    price=42000,
)

Direct HTX API with Authentication

HTX uses a specific signature scheme: URL-encode parameters in alphabetical order + HMAC-SHA256:

import hmac, hashlib, base64, urllib.parse, time

class HTXClient:
    BASE_URL = 'https://api.huobi.pro'
    
    def __init__(self, access_key: str, secret_key: str):
        self.access_key = access_key
        self.secret_key = secret_key
    
    def _sign(self, method: str, path: str, params: dict) -> str:
        params_sorted = sorted({
            'AccessKeyId': self.access_key,
            'SignatureMethod': 'HmacSHA256',
            'SignatureVersion': '2',
            'Timestamp': datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%S'),
            **params,
        }.items())
        
        query_string = urllib.parse.urlencode(params_sorted)
        payload = f"{method}\napi.huobi.pro\n{path}\n{query_string}"
        
        signature = hmac.new(
            self.secret_key.encode('utf-8'),
            payload.encode('utf-8'),
            hashlib.sha256
        ).digest()
        
        return base64.b64encode(signature).decode()
    
    def get_accounts(self):
        path = '/v1/account/accounts'
        params = {}
        sig = self._sign('GET', path, params)
        
        response = requests.get(
            f"{self.BASE_URL}{path}",
            params={
                **params,
                'AccessKeyId': self.access_key,
                'SignatureMethod': 'HmacSHA256',
                'SignatureVersion': '2',
                'Timestamp': datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%S'),
                'Signature': sig,
            }
        )
        return response.json()

WebSocket with gzip

HTX WebSocket uses gzip compression — requires decompression:

import websockets, gzip, json

async def subscribe_htx():
    async with websockets.connect('wss://api.huobi.pro/ws') as ws:
        # Subscribe to ticker
        await ws.send(json.dumps({
            'sub': 'market.btcusdt.ticker',
            'id': 'ticker-sub',
        }))
        
        async for message in ws:
            # Decompress gzip
            decompressed = gzip.decompress(message).decode('utf-8')
            data = json.loads(decompressed)
            
            # Respond to ping (HTX requires pong within 5 seconds)
            if 'ping' in data:
                await ws.send(json.dumps({'pong': data['ping']}))
                continue
            
            if 'ch' in data and 'tick' in data:
                ticker = data['tick']
                process_ticker(ticker['close'], ticker['vol'])

HTX Rate Limits

HTX restrictions: 10 requests/sec for private endpoints, 100 requests/sec for public. When exceeded — response {"status":"error","err-code":"api-limit-reached"}.

HTX also supports bulk order operations — placing multiple orders with one request, which helps in rate limit management for high-frequency strategies.

HTX API bot integration: 1–2 weeks. CCXT abstracts most HTX specifics, but direct API is needed for specific functions (bulk orders, margin, futures).