Developer Guide v2.0

Last updated: 2026-06-24 · BitUP Server v20+ · Swagger API →

1. Quick Start

2. Architecture

┌───────────────────────────────────────────────────────┐
│              Your Strategy Engine (Python/Node/Go)      │
│                                                       │
│  Market Data ──▶ Strategy Logic ──▶ POST /strategy/signal│
└──────────────────────┬────────────────────────────────┘
                       │ HTTPS + Bearer Token
                       ▼
┌──────────────────────────────────────────────────────┐
│                  BitUP Platform (Java)                 │
│                                                      │
│  ① Verify API Key → ② Find user binding               │
│  → ③ Decrypt exchange key → ④ Risk check              │
│  → ⑤ Deduct points → ⑥ Execute trade → ⑦ Record order │
└──────┬──────────────────────────────┬────────────────┘
       │                              │
       ▼                              ▼
┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│ User A Binance│  │ User B OKX   │  │ User C Hyper │
│ (User's own key)│  │ (User's own key)│  │ (User's own key)│
└─────────────┘  └─────────────┘  └─────────────┘

Key design: You never touch any user's exchange API keys. You only send signals like "User X buy BTC", and the platform executes with that user's own keys.

3. API Reference

Item	Value
Base URL (prod)	https://bitup.ai/api/v1
Auth	Authorization: Bearer <developerApiKey>
Content-Type	application/json

3.1 Send Trade Signal

POST /api/v1/strategy/signal

Request Body

Field	Type	Req	Description
user_id	Long	YES	Target user ID
symbol	String	YES	Trading pair, e.g. BTCUSDT
action	String	YES	BUY long / SELL close
quantity	BigDecimal	YES	Order quantity (base asset)
signal_id	String	YES	Unique signal ID, use UUID
order_type	String	NO	MARKET (default) / LIMIT
price	BigDecimal	NO	Required for LIMIT orders
leverage	Integer	NO	Leverage, default 1
take_profit	BigDecimal	NO	Take profit price
stop_loss	BigDecimal	NO	Stop loss price

Example

POST /api/v1/strategy/signal
Authorization: Bearer sk-your-api-key

{
    "user_id": 26,
    "symbol": "BTCUSDT",
    "action": "BUY",
    "quantity": 0.01,
    "signal_id": "550e8400-e29b-41d4-a716-446655440000",
    "order_type": "MARKET",
    "stop_loss": 61000
}

Success Response (200)

{
    "code": 200,
    "message": "success",
    "data": {
        "status": "ACCEPTED",
        "exchange_order_id": "binance-order-12345",
        "order_status": "FILLED",
        "points_before": 1500,
        "points_after": 1499,
        "signal_id": 42
    }
}

3.2 Query My Strategies

GET /api/v1/developer/strategies

3.3 Signal Status

Status	Meaning
ACCEPTED	Signal received, executing
PENDING	Waiting for exchange response
FILLED	Order fully filled
REJECTED	Rejected by risk check

4. Strategy Registration

4.1 Via Web UI

Login → Developer Center → Register Strategy → Submit for review → Get developerApiKey

4.2 Strategy Categories

Code	中文	Description
TREND_FOLLOWING	趋势跟踪	Follow the trend, buy high sell higher
MEAN_REVERSION	均值回归	Price reverts to mean after deviation
MOMENTUM	动量策略	Strong gets stronger, weak gets weaker
GRID	网格交易	Buy low sell high within range
ARBITRAGE	套利策略	Cross-exchange / funding rate arbitrage
ML_AI	机器学习	AI model prediction
MULTI_FACTOR	多因子	Multi-indicator scoring
CUSTOM	自定义	Other custom strategies

5. Sending Signals

5.1 Signal Flow

Your Engine              BitUP Platform
    │                        │
    │ ① POST /strategy/signal│
    │────────────────────────▶│
    │                        │ ② Verify API Key
    │                        │ ③ Find user binding
    │                        │ ④ Risk check
    │                        │ ⑤ Deduct 1 point
    │                        │ ⑥ Execute trade
    │ ⑦ Return result        │
    │◀────────────────────────│
    │ {status: "ACCEPTED"}   │

5.2 Signal Deduplication

signal_id is globally unique. Duplicate IDs are rejected:

{ "code": 4004, "message": "信号ID重复" }

5.3 Python Client

import requests, uuid

class BitUPClient:
    def __init__(self, api_key, base_url="https://bitup.ai/api/v1"):
        self.api_key = api_key
        self.base_url = base_url

    def send_signal(self, user_id, symbol, action, quantity, **kwargs):
        payload = {
            "user_id": user_id, "symbol": symbol,
            "action": action, "quantity": quantity,
            "signal_id": str(uuid.uuid4()),
            "order_type": kwargs.get("order_type", "MARKET"),
            "leverage": kwargs.get("leverage", 1),
        }
        if "stop_loss" in kwargs: payload["stop_loss"] = kwargs["stop_loss"]
        if "take_profit" in kwargs: payload["take_profit"] = kwargs["take_profit"]

        resp = requests.post(
            f"{self.base_url}/strategy/signal",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json=payload
        )
        return resp.json()

    def broadcast(self, user_ids, symbol, action, quantity, **kwargs):
        """Send same signal to multiple users"""
        return [{"user_id": uid, "result": self.send_signal(uid, symbol, action, quantity, **kwargs)}
                for uid in user_ids]

# Usage
client = BitUPClient("sk-your-api-key")
result = client.send_signal(26, "BTCUSDT", "BUY", 0.01, stop_loss=61000)
print(result["data"]["status"])  # "ACCEPTED"

5.4 Node.js Client

import crypto from 'crypto';

class BitUPClient {
    constructor(apiKey, baseUrl = 'https://bitup.ai/api/v1') {
        this.apiKey = apiKey; this.baseUrl = baseUrl;
    }

    async sendSignal({ userId, symbol, action, quantity, orderType = 'MARKET', stopLoss, takeProfit, leverage = 1 }) {
        const payload = {
            user_id: userId, symbol, action, quantity,
            signal_id: crypto.randomUUID(), order_type: orderType, leverage,
            ...(stopLoss && { stop_loss: stopLoss }),
            ...(takeProfit && { take_profit: takeProfit }),
        };
        const resp = await fetch(`${this.baseUrl}/strategy/signal`, {
            method: 'POST',
            headers: { Authorization: `Bearer ${this.apiKey}`, 'Content-Type': 'application/json' },
            body: JSON.stringify(payload),
        });
        return resp.json();
    }
}

6. Risk Controls

Check	Rule	Rejection Status
Daily Loss Limit	Cumulative daily PnL ≤ user limit	REJECTED
Position Limit	Single symbol position ≤ user limit	REJECTED
Leverage Limit	Signal leverage ≤ strategy max	REJECTED
Strategy Status	Strategy ACTIVE, binding RUNNING	REJECTED
API Key Validity	User's exchange key working	REJECTED
Points Balance	User points ≥ 1	REJECTED

7. Points & Billing

User subscribes → spends subscriptionPoints (e.g. 500 points)
         ↓
Each signal executes → deducts 1 point
         ↓
Points go to strategy developer
         ↓
Developer can withdraw points as USDT (min 50 USDT)

8. Exchange Support

Exchange	Code	Type	Symbol Format
Binance	BINANCE	Spot	BTCUSDT
OKX	OKX	Spot	BTC-USDT
HyperLiquid	HYPERLIQUID	Perpetual	BTC
MT5	MT5	Forex/Gold/Oil	XAUUSD, US30

API Key Permissions Required

Exchange	Required
Binance	Enable Spot Trading, DISABLE Withdrawal
OKX	Enable Trading, DISABLE Withdrawal
HyperLiquid	Enable Trading

9. Full Example: SMA Crossover Strategy

"""
BTC Dual Moving Average Strategy
- Short MA crosses above Long MA → BUY
- Short MA crosses below Long MA → SELL
"""
import time, uuid, requests
from collections import deque

API_KEY = "sk-your-api-key"
BASE = "https://bitup.ai/api/v1"
USERS = [26, 30, 40]  # Subscribed user IDs

class SMACrossover:
    def __init__(self, symbol="BTCUSDT", short=5, long=20):
        self.symbol = symbol
        self.short, self.long = short, long
        self.prices = deque(maxlen=long + 1)
        self.positions = {}  # user_id → has_position

    def update(self, price): self.prices.append(price)

    def should_buy(self):
        if len(self.prices) < self.long: return False
        s1 = sum(list(self.prices)[-self.short:]) / self.short
        l1 = sum(list(self.prices)[-self.long:]) / self.long
        s0 = sum(list(self.prices)[-self.short-1:-1]) / self.short
        l0 = sum(list(self.prices)[-self.long-1:-1]) / self.long
        return s0 <= l0 and s1 > l1  # Golden cross

    def should_sell(self):
        if len(self.prices) < self.long: return False
        s1 = sum(list(self.prices)[-self.short:]) / self.short
        l1 = sum(list(self.prices)[-self.long:]) / self.long
        s0 = sum(list(self.prices)[-self.short-1:-1]) / self.short
        l0 = sum(list(self.prices)[-self.long-1:-1]) / self.long
        return s0 >= l0 and s1 < l1  # Death cross

    def send(self, uid, action, qty=0.01):
        r = requests.post(f"{BASE}/strategy/signal",
            headers={"Authorization": f"Bearer {API_KEY}"},
            json={"user_id": uid, "symbol": self.symbol,
                  "action": action, "quantity": qty,
                  "signal_id": str(uuid.uuid4())})
        data = r.json()
        ok = data["code"] == 200
        print(f"{'✅' if ok else '❌'} User {uid} {action} → {data.get('message','')}")
        if ok: self.positions[uid] = (action == "BUY")

    def run(self):
        while True:
            price = self.get_price()  # TODO: real API
            self.update(price)
            if self.should_buy():
                for uid in USERS:
                    if not self.positions.get(uid): self.send(uid, "BUY")
            elif self.should_sell():
                for uid in USERS:
                    if self.positions.get(uid): self.send(uid, "SELL")
            time.sleep(60)

    def get_price(self): return 65000.0  # Replace with API

if __name__ == "__main__":
    SMACrossover().run()

10. Error Codes

Code	Message	Action
200	Success	-
401	Invalid API Key	Check developerApiKey
4003	Strategy API Key invalid	Check strategy status
4004	Duplicate signal ID	Generate new UUID
2001	User points insufficient	Signal rejected, no deduction
5001	Daily loss limit reached	Wait for next day
5002	Position limit exceeded	Reduce quantity
4001	Strategy not found	Check review status
4002	Strategy not active	Wait for approval