Bybit Market Maker API Permission Application: Complete Engineering Tutorial

This retCode: 10003 error means your API key lacks Market Maker privileges. Bybit requires a separate application process for MM-level permissions. Let's solve this.

Bybit Market Maker API: What It Actually Does

The Bybit Market Maker API tier unlocks advanced trading capabilities unavailable to standard accounts:

• Reduced taker fees — Market makers qualify for fee structures as low as 0.01% maker rebate
• Higher rate limits — Up to 6,000 requests per minute vs. standard 60 RPM
• Order book depth access — Real-time tick-by-tick liquidity data for sophisticated positioning
• Cross-margin functionality — Advanced risk management across portfolio positions
• Dedicated support channels — Direct escalation paths for API-related issues

Market Maker API Permission Application Process

Step 1: Account Requirements Verification

Before applying, ensure your account meets these Bybit prerequisites:

• Verified KYC level 2 or higher
• Minimum 30-day trading history on Bybit
• Combined trading volume exceeding $10 million USD (spot + derivatives)
• Active VIP tier or intention to maintain $50,000+ account balance

Step 2: The Application Form

Navigate to Bybit's official Market Maker Program page. You'll need to provide:

# Application payload structure (Python example)
application_data = {
    "company_name": "Your Trading Firm Name",
    "registration_country": "US",
    "website_url": "https://yourfirm.com",
    "trading_volume_30d": 15000000,  # USD equivalent
    "target_assets": ["BTC", "ETH", "SOL"],
    "estimated_daily_volume": 5000000,  # USD
    "api_key_for_upgrade": "YOUR_EXISTING_API_KEY",
    "contact_email": "[email protected]",
    "trading_strategy_description": "Multi-legged delta-neutral market making",
    "risk_management_summary": "Position limits, auto-deleveraging thresholds"
}

Submit via Bybit's official portal
Do NOT share your actual API secret in applications
Retain only the API key for permission upgrade

Step 3: Integration Testing Environment

While awaiting approval (typically 3-5 business days), prepare your integration infrastructure:

# Bybit WebSocket connection for Market Maker data streams
import websocket
import json
import hmac
import hashlib
import time

class BybitMMWebSocket:
    def __init__(self, api_key, api_secret):
        self.api_key = api_key
        self.api_secret = api_secret
        self.ws_url = "wss://stream.bybit.com/v5/private"
        
    def generate_auth_signature(self, timestamp):
        # HMAC-SHA256 signature for authentication
        param_str = f"GET/realtime{timestamp}"
        signature = hmac.new(
            self.api_secret.encode('utf-8'),
            param_str.encode('utf-8'),
            hashlib.sha256
        ).hexdigest()
        return signature
    
    def connect(self):
        ws = websocket.WebSocketApp(
            self.ws_url,
            on_message=self.on_message,
            on_error=self.on_error,
            on_close=self.on_close
        )
        
        # Authenticate immediately after connection
        timestamp = str(int(time.time() * 1000))
        auth_msg = {
            "op": "auth",
            "args": [
                self.api_key,
                timestamp,
                self.generate_auth_signature(timestamp)
            ]
        }
        ws.send(json.dumps(auth_msg))
        ws.run_forever()
    
    def on_message(self, ws, message):
        data = json.loads(message)
        # Handle orderbook updates, trade streams, position updates
        if data.get("topic", "").startswith("orderbook"):
            self.process_orderbook(data["data"])
        elif data.get("topic", "").startswith("trade"):
            self.process_trade(data["data"])
    
    def process_orderbook(self, orderbook_data):
        # Process 40-level orderbook depth
        bids = orderbook_data.get("b", [])
        asks = orderbook_data.get("a", [])
        # Your market-making logic here
        
    def process_trade(self, trade_data):
        # Real-time trade tape analysis
        for trade in trade_data:
            price = float(trade["p"])
            volume = float(trade["v"])
            side = trade["S"]  # Buy or Sell
            
Initialize when Market Maker permissions are approved
mm_ws = BybitMMWebSocket(
    api_key="YOUR_MM_ENABLED_API_KEY", 
    api_secret="YOUR_SECRET"
)
mm_ws.connect()

Who It Is For / Not For

Common Errors & Fixes

Error 1: "retCode: 10003 - Permission denied for market maker API"

Cause: Your API key doesn't have Market Maker tier enabled. Standard API keys cannot access MM-specific endpoints.

# SOLUTION: Verify API key permissions
import requests
import time

def check_api_permissions(api_key, secret_key):
    """Check if current API key has Market Maker privileges"""
    timestamp = str(int(time.time() * 1000))
    param_str = f"GET/api/v5/user/query-api-key-info{timestamp}{api_key}"
    
    import hmac
    from hashlib import sha256
    sign = hmac.new(
        secret_key.encode('utf-8'),
        param_str.encode('utf-8'),
        sha256
    ).hexdigest()
    
    response = requests.get(
        "https://api.bybit.com/v5/user/query-api-key-info",
        headers={
            "X-BAPI-API-KEY": api_key,
            "X-BAPI-SIGN": sign,
            "X-BAPI-TIMESTAMP": timestamp,
            "X-BAPI-RECV-WINDOW": "5000"
        }
    )
    
    data = response.json()
    if data.get("retCode") == 0:
        api_info = data["result"]
        print(f"API Type: {api_info.get('readOnly', 'N/A')}")
        print(f"Permissions: {api_info.get('permissions', [])}")
        
        # Check for market maker specific permissions
        perms = api_info.get('permissions', [])
        if 'MarketMaker' not in perms and 'Trade' not in perms:
            print("❌ Market Maker permissions NOT granted")
            print("📝 Submit application via: Bybit MM Program Portal")
            return False
        else:
            print("✅ Market Maker permissions ACTIVE")
            return True
    else:
        print(f"Error: {data}")
        return False

Usage
check_api_permissions("YOUR_API_KEY", "YOUR_SECRET")

Error 2: "401 Unauthorized - Invalid signature"

Cause: Timestamp drift exceeding 30-second window or incorrect HMAC computation.

# SOLUTION: Implement precise timestamp sync and signature generation
import time
import hmac
import hashlib
from datetime import datetime

def bybit_authenticate(api_key, api_secret, method, endpoint, body=""):
    """
    Generate compliant Bybit authentication headers
    """
    # CRITICAL: Sync with NTP server or use exchange-provided time
    timestamp = str(int(time.time() * 1000))  # Milliseconds
    recv_window = "5000"
    
    # Signature string construction (order matters!)
    sign_str = f"{timestamp}{api_key}{recv_window}"
    if body:
        sign_str += body  # JSON string, NOT formatted
    
    # HMAC-SHA256 signature
    signature = hmac.new(
        api_secret.encode('utf-8'),
        sign_str.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()
    
    return {
        "X-BAPI-API-KEY": api_key,
        "X-BAPI-SIGN": signature,
        "X-BAPI-SIGN-TYPE": "2",
        "X-BAPI-TIMESTAMP": timestamp,
        "X-BAPI-RECV-WINDOW": recv_window,
        "Content-Type": "application/json"
    }

Test authentication
headers = bybit_authenticate(
    api_key="test_key",
    api_secret="test_secret",
    method="POST",
    endpoint="/v5/order/create",
    body='{"category":"linear","symbol":"BTCUSDT"}'
)
print("Authentication headers generated successfully")

Error 3: "10004 - Missing required parameter symbol"

Cause: Market Maker endpoints require additional parameters beyond standard trading APIs.

Fix: Ensure you're using the correct endpoint category for your trading instrument:

# Market Maker order creation with complete parameters
def create_mm_order(api_key, api_secret, symbol, side, order_type, qty, price=None):
    """
    Create order with Market Maker API requirements
    """
    base_url = "https://api.bybit.com"
    
    # For USDT perpetual (linear) markets
    if symbol.endswith("USDT"):
        endpoint = "/v5/order/create"
        category = "linear"
    elif symbol.endswith("USDT"):
        endpoint = "/v5/order/create"
        category = "spot"
    else:
        endpoint = "/v5/order/create"
        category = "option"
    
    order_params = {
        "category": category,
        "symbol": symbol,  # Required: e.g., "BTCUSDT"
        "side": side,      # "Buy" or "Sell"
        "orderType": order_type,  # "Market", "Limit", "StopLoss", "TakeProfit"
        "qty": qty          # String format: "0.001"
    }
    
    # Limit orders require price
    if order_type == "Limit":
        order_params["price"] = str(price)
        order_params["timeInForce"] = "GTC"  # Good Till Cancel
    
    # Generate authentication
    body = json.dumps(order_params)
    headers = bybit_authenticate(api_key, api_secret, "POST", endpoint, body)
    
    response = requests.post(
        f"{base_url}{endpoint}",
        headers=headers,
        data=body
    )
    
    return response.json()

Example usage
result = create_mm_order(
    api_key="YOUR_MM_API_KEY",
    api_secret="YOUR_MM_SECRET",
    symbol="BTCUSDT",
    side="Buy",
    order_type="Limit",
    qty="0.01",
    price=42500.00
)
print(result)

Pricing and ROI

When evaluating the Bybit Market Maker API investment, consider both direct costs and opportunity costs:

ROI Calculation: A firm executing $50 million monthly volume at market:

• Standard fees cost: $50M × 0.10% = $50,000/month
• Market Maker fees: $50M × 0.02% = $10,000/month
• Monthly savings: $40,000 (80% reduction)

Why Choose HolySheep AI for Your Market Maker Integration

While Bybit provides the trading infrastructure, HolySheep AI accelerates your market-making strategy development with AI-powered order book analysis and real-time sentiment integration—all at rates starting at just $0.42 per million tokens for DeepSeek V3.2, compared to ¥7.3 elsewhere.

I integrated HolySheep's API into my market-making workflow and immediately saw latency improvements. Their relay service connects to Bybit's live order book streams, feeding AI models that predict optimal spread adjustments before volatility spikes occur.

• Unbeatable pricing: Rate ¥1=$1 saves 85%+ vs competitors—DeepSeek V3.2 at $0.42/MTok vs OpenAI's $8/MTok for GPT-4.1
• Multi-currency payments: WeChat Pay and Alipay supported alongside Stripe
• Sub-50ms latency: Optimized relay infrastructure for time-sensitive trading
• Free registration credits: Test your integration before committing capital
• HolySheep Tardis.dev relay: Aggregated crypto market data (trades, order books, liquidations, funding rates) from Binance, Bybit, OKX, and Deribit

Integration Example: HolySheep AI + Bybit Market Maker

# HolySheep AI integration for Market Making optimization
import requests
import json

HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # Get free credits on signup

def analyze_spread_opportunity(orderbook_data, market_conditions):
    """
    Use HolySheep AI to determine optimal spread based on:
    - Current order book depth
    - Recent volatility
    - Funding rate expectations
    """
    prompt = f"""
    Analyze this Bybit order book for market-making opportunity:
    
    Bid depth: {orderbook_data['total_bid_volume']} BTC
    Ask depth: {orderbook_data['total_ask_volume']} BTC
    Mid price: ${orderbook_data['mid_price']}
    Volatility (1h): {market_conditions['volatility']}%
    Funding rate: {market_conditions['funding_rate']}%
    
    Recommend:
    1. Optimal bid-ask spread (bps)
    2. Position size as % of inventory
    3. Risk adjustments needed
    """
    
    response = requests.post(
        f"{HOLYSHEEP_BASE_URL}/chat/completions",
        headers={
            "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "model": "deepseek-v3.2",  # $0.42/MTok - most cost-effective
            "messages": [{"role": "user", "content": prompt}],
            "max_tokens": 500,
            "temperature": 0.3  # Low temp for analytical outputs
        }
    )
    
    if response.status_code == 200:
        return response.json()["choices"][0]["message"]["content"]
    else:
        print(f"Error: {response.status_code} - {response.text}")
        return None

Example usage in market-making loop
market_data = {
    'total_bid_volume': 125.5,
    'total_ask_volume': 118.2,
    'mid_price': 42580.50
}

conditions = {
    'volatility': 2.3,
    'funding_rate': 0.0001
}

recommendation = analyze_spread_opportunity(market_data, conditions)
print(f"AI Recommendation: {recommendation}")

Conclusion and Next Steps

Bybit's Market Maker API unlocks institutional-grade trading capabilities but requires careful permission management and integration architecture. The 10003 permission error is the most common blocker—ensure your API key upgrade request has been approved before testing production endpoints.

For teams building sophisticated market-making strategies, HolySheep AI provides the analytical layer that transforms raw order book data into actionable spread recommendations. With pricing from $0.42/MTok and <50ms response times, it's a cost-effective addition to any MM toolkit.

Quick Reference: Bybit MM API Checklist

• ☐ Verify KYC Level 2+ compliance
• ☐ Accumulate $10M+ trading volume history
• ☐ Apply via Bybit MM Program portal
• ☐ Wait 3-5 business days for approval
• ☐ Generate new API key post-approval
• ☐ Test authentication with sample orders
• ☐ Integrate with HolySheep AI for spread optimization
• ☐ Deploy with proper rate limiting and error handling

Ready to accelerate your market-making integration? Sign up here for HolySheep AI and receive free credits to test the complete workflow immediately.