Spot Trading

The following section outlines the authentication requirements and provides code snippets for accessing the Spot API.

Authentication Type:

Interface Type	Authentication Required
RESTful Public Interface	No authentication required
RESTful Private Interface	Requires API Key and Signature
Websocket Public Interface	Requires Public Token
Websocket Private Interface	Requires API Key and Secret Key

Code Snippets

RESTful Public Interface

Python

import requests

def SpotRestfulPublic(api_url, params):
    base_url= "https://api.coinw.com"
    url = f'{base_url}{api_url}'

    response = requests.get(url, params)
    if response.status_code == 200:
        return response.json()
    else:
        return print("Failed to get data. Status code:", response.status_code)

Java

package com.coinw.test.busi.publicCode;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

public class SpotRestfulPublic {
    private static final String BASE_URL = "https://api.coinw.com";

    public static String spotRestfulPublic(String apiUrl, Map<String, String> params) {
        try {
            StringBuilder paramString = new StringBuilder();
            if (params != null && !params.isEmpty()) {
                for (Map.Entry<String, String> entry : params.entrySet()) {
                    if (paramString.length() > 0) {
                        paramString.append("&");
                    }
                    paramString.append(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8))
                            .append("=")
                            .append(URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8));
                }
            }

            String fullUrl = BASE_URL + apiUrl;
            if (paramString.length() > 0) {
                if (fullUrl.contains("?")) {
                    fullUrl += "&" + paramString.toString();
                } else {
                    fullUrl += "?" + paramString.toString();
                }
            }

            URL url = new URL(fullUrl);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");

            int responseCode = connection.getResponseCode();
            if (responseCode == 200) {
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuilder response = new StringBuilder();
                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();
                return response.toString();
            } else {
                System.out.println("Failed to get data. Status code: " + responseCode);
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        // Get 24H Trade Summary for All Instruments（获取所有交易品种24小时交易摘要）
        String apiUrl1 = "/api/v1/public?command=returnTicker";
        Map<String, String> params1 = new HashMap<>();
        String result1 = spotRestfulPublic(apiUrl1, params1);
        System.out.println("Result: " + result1);

        // Get Currency Information（获取数字货币信息）
        String apiUrl2 = "/api/v1/public?command=returnCurrencies";
        Map<String, String> params2 = new HashMap<>();
        String result2 = spotRestfulPublic(apiUrl2, params2);
        System.out.println("Result: " + result2);

        // Get Instrument Information（获取交易品种信息）
        String apiUrl3 = "/api/v1/public?command=returnSymbol";
        Map<String, String> params3 = new HashMap<>();
        String result3 = spotRestfulPublic(apiUrl3, params3);
        System.out.println("Result: " + result3);

        // Get Order Book（获取订单簿）
        String apiUrl4 = "/api/v1/public?command=returnOrderBook";
        Map<String, String> params4 = new HashMap<>();
        params4.put("size", "5");
        params4.put("symbol", "BTC_USDT");
        String result4 = spotRestfulPublic(apiUrl4, params4);
        System.out.println("Result: " + result4);

        // Get Recent Trades（获取最近成交）
        String apiUrl5 = "/api/v1/public?command=returnTradeHistory";
        Map<String, String> params5 = new HashMap<>();
        params5.put("symbol", "BTC_USDT");
        params5.put("end", "1581916917660");
        String result5 = spotRestfulPublic(apiUrl5, params5);
        System.out.println("Result: " + result5);

        // Get K-Line（获取K线）
        String apiUrl6 = "/api/v1/public?command=returnChartData";
        Map<String, String> params6 = new HashMap<>();
        params6.put("currencyPair", "BTC_USDT");
        params6.put("period", "300");
        params6.put("start", "1579238517000");
        params6.put("end", "1581916917660");
        String result6 = spotRestfulPublic(apiUrl6, params6);
        System.out.println("Result: " + result6);

        // Get 24H Volume for Popular Instruments（获取热门交易品种24小时交易量）
        String apiUrl7 = "/api/v1/public?command=return24hVolume";
        Map<String, String> params7 = new HashMap<>();
        String result7 = spotRestfulPublic(apiUrl7, params7);
        System.out.println("Result: " + result7);
    }
}

RESTful Private Interface

Python

import hashlib
import urllib
import urllib.parse
import urllib.request
import requests
import random
def SpotRestfulPrivate(host, api_url, method, api_key, params, secret_key):
    params["api_key"] = api_key
    sorted_params = sorted(params.items(), key=lambda d: d[0], reverse=False)
    encode_params = ""
    for i in sorted_params:
        a = i[0] + "=" + str(i[1]) + "&"
        encode_params = encode_params + a
    sign_params = encode_params + "secret_key=" + secret_key
    input_name = hashlib.md5()
    input_name.update(sign_params.encode("utf-8"))
    sign = input_name.hexdigest()
    sign = sign.upper()
    encode_params_req = urllib.parse.urlencode(params)

    host = "{host}{api_url}&sign={sign}&{encode_params_req}".format(
        host=host, api_url=api_url, sign=sign, encode_params_req=encode_params_req)
    
    if method.upper() == "POST":
        response = requests.post(host, data={}, headers={"Content-type": "application/json"})
        return response.json()

    if method.upper() == "GET":
        response = requests.get(host, params={}, headers={"Content-type": "application/json"})
        return response.json()
host = "https://api.coinw.com"
secret_key = "your_secret_key"
api_key= "your_api_key"

Java

package com.coinw.test.busi.privateCode;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;


public class SpotRestfulPrivate {

    private static final String BASE_URL = "https://api.coinw.com";
    private static final String SEC_KEY = ""YOUR_SECRET_KEY"";
    private static final String API_KEY = ""YOUR_PRIVATE_KEY";

    public static String spotRestfulPrivate( String apiUrl, String method,  Map<String, Object> params) throws Exception {
        params.put("api_key", API_KEY);

        // 对参数进行排序
        List<Map.Entry<String, Object>> sortedParams = new ArrayList<>(params.entrySet());
        sortedParams.sort(Map.Entry.comparingByKey());

        StringBuilder encodeParams = new StringBuilder();
        for (Map.Entry<String, Object> entry : sortedParams) {
            encodeParams.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
        }

        String signParams = encodeParams + "secret_key=" + SEC_KEY;
        String sign = md5(signParams).toUpperCase();

        StringBuilder encodeParamsReq = new StringBuilder();
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            if (encodeParamsReq.length() > 0) {
                encodeParamsReq.append("&");
            }
            encodeParamsReq.append(entry.getKey()).append("=").append(entry.getValue());
        }

        String requestUrl = BASE_URL + apiUrl + "&sign=" + sign + "&" + encodeParamsReq;

        if (method.equalsIgnoreCase("POST")) {
            return sendPostRequest(requestUrl);
        } else if (method.equalsIgnoreCase("GET")) {
            return sendGetRequest(requestUrl);
        }
        return null;
    }

    private static String md5(String input) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] digest = md.digest(input.getBytes(StandardCharsets.UTF_8));
        StringBuilder hexString = new StringBuilder();
        for (byte b : digest) {
            String hex = Integer.toHexString(0xFF & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }

    private static String sendPostRequest(String url) throws Exception {
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
        con.setRequestMethod("POST");
        con.setRequestProperty("Content-type", "application/json");

        con.setDoOutput(true);
        try (OutputStream os = con.getOutputStream()) {
            byte[] input = new byte[0];
            os.write(input, 0, input.length);
        }

        int responseCode = con.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            try (BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()))) {
                StringBuilder response = new StringBuilder();
                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                return response.toString();
            }
        }
        return null;
    }

    private static String sendGetRequest(String url) throws Exception {
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
        con.setRequestMethod("GET");
        con.setRequestProperty("Content-type", "application/json");

        int responseCode = con.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            try (BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()))) {
                StringBuilder response = new StringBuilder();
                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                return response.toString();
            }
        }
        return null;
    }

    public static void main(String[] args) {
        try {

            //  Place an Order（下单）
            System.out.println("-----   Place an Order（下单）  ----");
            String apiUrl6 = "/api/v1/private?command=doTrade";
            String method6 = "POST";
            Map<String, Object> params6 = new HashMap<>();
            params6.put("symbol", "ETH_USDT");
            params6.put("type", "0"); // 0-buy order, 1-sell order
            params6.put("amount", "0.1"); // Order quantity
            params6.put("rate", "100"); // Commission Price
//            params6.put("isMarket", "false");
            params6.put("out_trade_no", "213412342134228");
//            params6.put("funds", "100");  // Amount, market order is valid
            String s = spotRestfulPrivate(apiUrl6, method6, params6);
            System.out.println(s);


            // Get Current Orders (获取当前订单)
            System.out.println("----   Get Current Orders (获取当前订单)  ----");
            String apiUrl = "/api/v1/private?command=returnOpenOrders";
            String method = "POST";
            Map<String, Object> params = new HashMap<>();
            params.put("currencyPair", "ETH_USDT");
            System.out.println(spotRestfulPrivate( apiUrl, method, params));


            //  Get Order Information (获取订单信息)
            System.out.println("-----   Get Order Information (获取订单信息) ---");
            String apiUrl2 = "/api/v1/private?command=returnOrderTrades";
            String method2 = "POST";
            Map<String, Object> params2 = new HashMap<>();
            System.out.println(spotRestfulPrivate( apiUrl2, method2, params2));

            //  Get Order Status (获取订单状态)
            System.out.println("----  Get Order Status (获取订单状态) ----");
            String apiUrl3 = "/api/v1/private?command=returnOrderStatus";
            String method3 = "POST";
            Map<String, Object> params3 = new HashMap<>();
            System.out.println(spotRestfulPrivate( apiUrl3, method3, params3));

            //  Get Transection History (获取交易历史)
            System.out.println("-----   Get Transection History (获取交易历史)   ----");
            String apiUrl4 = "/api/v1/private?command=returnUTradeHistory";
            String method4 = "POST";
            Map<String, Object> params4 = new HashMap<>();
            params4.put("currencyPair", "ETH_USDT");
            System.out.println(spotRestfulPrivate( apiUrl4, method4, params4));


            //  Get Historical Orders (获取历史订单)
            System.out.println("-----   Get Historical Orders (获取历史订单)  ----");
            String apiUrl5 = "/api/v1/private?command=getUserTrades";
            String method5 = "POST";
            Map<String, Object> params5 = new HashMap<>();
            params5.put("symbol", "ETH_USDT");
            System.out.println(spotRestfulPrivate( apiUrl5, method5, params5));


            //  Cancel an Order (取消订单)
            System.out.println("-----   Cancel an Order (取消订单)    ----");
            String apiUrl7 = "/api/v1/private?command=cancelOrder";
            String method7 = "POST";
            Map<String, Object> params7 = new HashMap<>();
            System.out.println(spotRestfulPrivate( apiUrl7, method7, params7));

            //   Cancel All Orders (取消所有订单)
            System.out.println("----    Cancel All Orders (取消所有订单)    ----");
            String apiUrl8 = "/api/v1/private?command=cancelAllOrder";
            String method8 = "POST";
            Map<String, Object> params8 = new HashMap<>();
            params8.put("currencyPair", "ETH_USDT");
            System.out.println(spotRestfulPrivate( apiUrl8, method8, params8));

            //  Get Spot Account Balance (获取现货账户余额)
            System.out.println("----   Get Spot Account Balance (获取现货账户余额) ----");
            String apiUrl9 = "/api/v1/private?command=returnBalances";
            String method9 = "POST";
            Map<String, Object> params9 = new HashMap<>();
            System.out.println(spotRestfulPrivate( apiUrl9, method9, params9));

            //  Get Full Spot Account Balance (获取完整现货账户余额)
            System.out.println("----   Get Full Spot Account Balance (获取完整现货账户余额)    ----");
            String apiUrl10 = "/api/v1/private?command=returnCompleteBalances";
            String method10 = "POST";
            Map<String, Object> params10 = new HashMap<>();
            System.out.println(spotRestfulPrivate( apiUrl10, method10, params10));

            //  Get Deposit & Withdrawal Histroy (获取充值和提现历史)
            System.out.println("----   Get Deposit & Withdrawal Histroy (获取充值和提现历史)    ----");
            String apiUrl11 = "/api/v1/private?command=returnDepositsWithdrawals";
            String method11 = "POST";
            Map<String, Object> params11 = new HashMap<>();
            params11.put("symbol", "BTC");
            System.out.println(spotRestfulPrivate( apiUrl11, method11, params11));

            //  Get Deposit & Withrawal Address (获取充值和提现地址)
            System.out.println("----   Get Deposit & Withrawal Address (获取充值和提现地址)   ----");
            String apiUrl12 = "/api/v1/private?command=returnDepositAddresses";
            String method12 = "POST";
            Map<String, Object> params12 = new HashMap<>();
            params12.put("symbolId", "USDT"); //  use currency ID
            params12.put("chain", "BTC");
            System.out.println(spotRestfulPrivate( apiUrl12, method12, params12));


            //  Initiate Withdrawal (发起提现)
            System.out.println("----   提现   Initiate Withdrawal   ----");
            String apiUrl13 = "/api/v1/private?command=doWithdraw";
            String method13 = "POST";
            Map<String, Object> params13 = new HashMap<>();
            params13.put("amount", "0.5");
            params13.put("type", "internal_transfer");
            params13.put("currency", "HC");
            params13.put("address", "3491077");
            params13.put("memo", "None");
            params13.put("innerToType", 1);
            System.out.println(spotRestfulPrivate( apiUrl13, method13, params13));


            //Cancel Withdrawal (取消提现)
            System.out.println("----   取消提现  Cancell Withdrawal   ----");
            String apiUrl14 = "/api/v1/private?command=cancelWithdraw";
            String method14 = "POST";
            Map<String, Object> params14 = new HashMap<>();
            params14.put("id", "1");
            System.out.println(spotRestfulPrivate( apiUrl14, method14, params14));


            // Transfer Asset (资产转账)
            System.out.println("----   划转 Transfer Asset   ----");
            String apiUrl15 = "/api/v1/private?command=spotWealthTransfer";
            String method15 = "POST";
            Map<String, Object> params15 = new HashMap<>();
            params15.put("accountType", "SPOT"); //# must specify this. otherwise you will get succes, but not the job done
            params15.put("targetAccountType", "WEALTH");
            params15.put("bizType", "SPOT_TO_WEALTH");
            params15.put("coinCode", "BTC");
            params15.put("amount", new BigDecimal("0.0001"));
            System.out.println(spotRestfulPrivate( apiUrl15, method15, params15));



        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Websocket Public Interface

Python

Method 1

# Method 1
 
import requests
import socketio
 
def SpotWebsocketPublic(args:str):
 
    res = requests.get("https://www.coinw.com/pusher/public-token")
    token = res.json().get("data")["token"]
     
    sio = socketio.Client(reconnection=True)
    print(args)
 
    @sio.event
    def connect():
        sio.emit("subscribe", {"args": args})
     
    @sio.on('subscribe')
    def on_message(data):
        print(data)
 
    @sio.event
    def disconnect():
        print('disconnected from server')
 
    sio.connect(f'wss://ws.futurescw.info?token={token}', transports=['websocket'])
    sio.wait()

Method 2

# Method 2
 
import websocket
import json
import time

def SpotWebsocketPublic(url, subscription_params):
    try:
        ws = websocket.WebSocket()
        ws.connect(url)

        # Send subscription message
        ws.send(json.dumps(subscription_params))
        print("Subscription sent")

        while True:
            # Send ping
            ws.send(json.dumps({"event": "ping"}))
            print("Ping sent")

            # Receive and print message
            response = ws.recv()
            print(" Received:", response)

            time.sleep(10)

    except KeyboardInterrupt:
        print("Disconnected by user.")
        ws.close()
    except Exception as e:
        print(" Error:", e)
        ws.close()

Java

Method 1

package com.coinw.test.busi.publicCode;

import io.socket.client.IO;
import io.socket.client.Socket;
import okhttp3.*;
import org.json.JSONObject;
import javax.net.ssl.*;
import java.security.cert.X509Certificate;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class SpotWebsocketPublic {
    private static final String TOKEN_URL = "https://www.coinw.com/pusher/public-token";
    private static String WS_BASE_URL;
    private static final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();

    public static void main(String[] args) throws Exception {
        OkHttpClient unsafeHttpClient = createUnsafeHttpClient();

        Request tokenRequest = new Request.Builder().url(TOKEN_URL).build();
        String token;
        try (Response response = unsafeHttpClient.newCall(tokenRequest).execute()) {
            JSONObject json = new JSONObject(response.body().string());
            token = json.getJSONObject("data").getString("token");
            WS_BASE_URL = json.getJSONObject("data").getString("endpoint");
            System.out.println("Token: " + token);
        }

        IO.Options options = new IO.Options();
        options.transports = new String[]{"websocket"};
        options.secure = true; // 必须启用SSL

        Socket socket = IO.socket(WS_BASE_URL + "?token=" + token, options);

        socket.on(Socket.EVENT_CONNECT, args1 -> {
            System.out.println("Connected");

            // 添加心跳定时任务  Add heartbeat timer task
            scheduler.scheduleAtFixedRate(() -> {
                try {
                    JSONObject pingData = new JSONObject().put("event", "ping");
                    socket.emit("event", pingData);
                    System.out.println("Sent ping: " + pingData);
                } catch (Exception e) {
                    System.err.println("Ping failed: " + e.getMessage());
                }
            }, 0, 10, TimeUnit.SECONDS);


            //24H Trade Summary Subscription （24小时交易摘要订阅）
            String subscribeArgs = "spot/market-api-ticker:BTC-USDT";
            socket.emit("subscribe", new JSONObject().put("args", subscribeArgs));

            //Get K-Line（获取K线）
            subscribeArgs = "spot/candle-5m:BTC-USDT";
            socket.emit("subscribe", new JSONObject().put("args", subscribeArgs));

            //Order Book Subscription（订单簿订阅）
            subscribeArgs = "spot/level2:BTC-USDT";
            socket.emit("subscribe", new JSONObject().put("args", subscribeArgs));

            //Trades Subscription（交易订阅）
            subscribeArgs = "spot/match:BTC-USDT";
            socket.emit("subscribe", new JSONObject().put("args", subscribeArgs));

        }).on("subscribe", args1 -> {
            try {
                JSONObject data = (JSONObject) args1[0];
                System.out.println(data.toString());
            } catch (Exception e) {
                System.err.println("JSON Error: " + e.getMessage());
            }
        }).on(Socket.EVENT_DISCONNECT, args1 ->
                System.out.println("Disconnected"));

        // 6. 建立连接
        socket.connect();
        Runtime.getRuntime().addShutdownHook(new Thread(scheduler::shutdownNow));
        Thread.sleep(Long.MAX_VALUE);
    }

    // 创建信任所有证书的HTTP客户端（对应Python的verify=False）
    private static OkHttpClient createUnsafeHttpClient() throws Exception {
        X509TrustManager trustManager = new X509TrustManager() {
            public void checkClientTrusted(X509Certificate[] chain, String authType) {}
            public void checkServerTrusted(X509Certificate[] chain, String authType) {}
            public X509Certificate[] getAcceptedIssuers() { return new X509Certificate[0]; }
        };

        SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(null, new TrustManager[]{trustManager}, null);

        return new OkHttpClient.Builder()
                .sslSocketFactory(sslContext.getSocketFactory(), trustManager)
                .hostnameVerifier((hostname, session) -> true)
                .build();
    }
}

Method 2

package com.coinw.test.busi.publicCode;
 
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import org.json.JSONObject;
 
import java.net.URI;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
 
public class WebsocketPublic extends WebSocketClient {
    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
 
    public WebsocketPublic(URI serverUri) {
        super(serverUri);
    }
 
    @Override
    public void onOpen(ServerHandshake handshakedata) {
        startHeartbeat();
 
        //  K-Line Subscription（K线订阅）
        JSONObject subscriptionJson = new JSONObject();
        JSONObject paramsJson = new JSONObject();
        paramsJson.put("type", "candles");
        paramsJson.put("biz", "exchange");
        paramsJson.put("pairCode", "78");
        paramsJson.put("interval", "1m");
        subscriptionJson.put("event","sub"); // sub / unsub
        subscriptionJson.put("params",paramsJson);
        String subscription = subscriptionJson.toString();
        this.send(subscription);
 
 
//        //  Trades Subscription（交易订阅）
//        JSONObject subscriptionJson = new JSONObject();
//        JSONObject paramsJson = new JSONObject();
//        paramsJson.put("type", "fills");
//        paramsJson.put("biz", "exchange");
//        paramsJson.put("pairCode", "78");
//        subscriptionJson.put("event","sub"); // sub / unsub
//        subscriptionJson.put("params",paramsJson);
//        String subscription = subscriptionJson.toString();
//        this.send(subscription);
//
//
//        // Order Book Subscription（订单簿订阅）
//        JSONObject subscriptionJson = new JSONObject();
//        JSONObject paramsJson = new JSONObject();
//        paramsJson.put("type", "depth_snapshot");
//        paramsJson.put("biz", "exchange");
//        paramsJson.put("pairCode", "78");
//        subscriptionJson.put("event","sub"); // sub / unsub
//        subscriptionJson.put("params",paramsJson);
//        String subscription = subscriptionJson.toString();
//        this.send(subscription);
//
//
//        //Incremental Order Book Subscription（增量订单簿订阅）
//        JSONObject subscriptionJson = new JSONObject();
//        JSONObject paramsJson = new JSONObject();
//        paramsJson.put("type", "depth");
//        paramsJson.put("biz", "exchange");
//        paramsJson.put("pairCode", "78");
//        subscriptionJson.put("event","sub"); // sub / unsub
//        subscriptionJson.put("params",paramsJson);
//        String subscription = subscriptionJson.toString();
//        this.send(subscription);
//
//
//        //24H Trade Summary Subscription （24小时交易摘要订阅）
//        JSONObject subscriptionJson = new JSONObject();
//        JSONObject paramsJson = new JSONObject();
//        paramsJson.put("type", "ticker");
//        paramsJson.put("biz", "exchange");
//        paramsJson.put("pairCode", "78");
//        subscriptionJson.put("event","sub"); // sub / unsub
//        subscriptionJson.put("params",paramsJson);
//        String subscription = subscriptionJson.toString();
//        this.send(subscription);
//
//
//        //24H Trade Summary for All Instruments Subscription（所有交易工具的24小时交易摘要订阅）
//        JSONObject subscriptionJson = new JSONObject();
//        JSONObject paramsJson = new JSONObject();
//        paramsJson.put("type", "ticker_all");
//        paramsJson.put("biz", "exchange");
//        subscriptionJson.put("event","sub"); // sub / unsub
//        subscriptionJson.put("params",paramsJson);
//        String subscription = subscriptionJson.toString();
//        this.send(subscription);
 
    }
 
    @Override
    public void onMessage(String message) {
        System.out.println("Time"+new Date()+"    Received: " + message);
 
        try {
            JSONObject json = new JSONObject(message);
            // 处理心跳响应
            if (json.has("event") && "pong".equals(json.getString("event"))) {
                scheduleNextPing();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    private void startHeartbeat() {
        scheduler.schedule(this::sendPing, 10, TimeUnit.SECONDS);
    }
 
    private void scheduleNextPing() {
        if (!scheduler.isShutdown()) {
            scheduler.schedule(this::sendPing, 10, TimeUnit.SECONDS);
        }
    }
 
    public void sendPing() {
        if (this.isOpen()) {
            JSONObject ping = new JSONObject();
            ping.put("event", "ping");
            this.send(ping.toString());
            System.out.println("Sent ping");
        }
    }
 
    @Override
    public void onClose(int code, String reason, boolean remote) {
        System.out.println("Connection closed: " + reason);
        scheduler.shutdown();
    }
 
    @Override
    public void onError(Exception ex) {
        System.err.println("WebSocket error:");
        ex.printStackTrace();
    }
 
    public static void main(String[] args) throws Exception {
        URI uri = new URI("wss://ws.futurescw.com");
        WebsocketPublic client = new WebsocketPublic(
                uri);
        client.connect();
    }
}

Websocket Private Interface

Python

import websocket
import json
import time

def SpotWebsocketPrivate(url, subscription_payload, api_key, sec_key):
    try:
        ws = websocket.WebSocket()
        ws.connect(url)

        # send payload
        ws.send(json.dumps({"event": "login",
                            "params": { "api_key": api_key,
                                        "passphrase": sec_key}}))
        
        # send subscription
        ws.send(json.dumps(subscription_payload))


        
        while True:
            # Send ping
            ws.send(json.dumps({"event": "ping"}))
            print("Ping sent")

            # Receive and print message
            response = ws.recv()
            print(" Received:", response)

            time.sleep(0.5)

    except KeyboardInterrupt:
        print("Disconnected by user.")
        ws.close()
    except Exception as e:
        print(" Error:", e)
        ws.close()

Java

package com.coinw.test.busi.privateCode;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import org.json.JSONObject;

import java.net.URI;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class SpotWebsocketPrivate extends WebSocketClient {
    private final String API_KEY;
    private final String PASSPHRASE;
    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
    private boolean authenticated = false;

    public SpotWebsocketPrivate(URI serverUri, String apiKey, String passphrase) {
        super(serverUri);
        this.API_KEY = apiKey;
        this.PASSPHRASE = passphrase;
    }

    @Override
    public void onOpen(ServerHandshake handshakedata) {
        // login
        JSONObject login = new JSONObject();
        login.put("event", "login");
        JSONObject params = new JSONObject();
        params.put("api_key", API_KEY);
        params.put("passphrase", PASSPHRASE);
        login.put("params", params);
        this.send(login.toString());
        System.out.println("Sent login message");

        // Current Orders Subscription(当前订单订阅)
        JSONObject subscribeOrder = new JSONObject();
        subscribeOrder.put("event", "sub");
        JSONObject subParams = new JSONObject();
        subParams.put("biz", "exchange");
        subParams.put("type", "order");
        subscribeOrder.put("params", subParams);
        this.send(subscribeOrder.toString());
        System.out.println("Sent subscriptionOrder message");

        // Asset Subscription (资产订阅)
        JSONObject subscribeAssets = new JSONObject();
        subscribeAssets.put("event", "sub");
        JSONObject subParamsAssets = new JSONObject();
        subParamsAssets.put("biz", "exchange");
        subParamsAssets.put("type", "assets");
        subscribeAssets.put("params", subParams);
        this.send(subscribeAssets.toString());
        System.out.println("Sent subscriptionAssets message");


    }

    @Override
    public void onMessage(String message) {
        System.out.println("Received: " + message);

        try {
            JSONObject json = new JSONObject(message);
            // 处理登录响应
            if (json.has("channel") && "login".equals(json.getString("channel"))) {
                if (json.getJSONObject("data").getBoolean("result")) {
                    authenticated = true;
                    startHeartbeat();
                }
            }
            // 处理心跳响应
            if (json.has("event") && "pong".equals(json.getString("event"))) {
                scheduleNextPing();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void startHeartbeat() {
        scheduler.schedule(this::sendPing, 10, TimeUnit.SECONDS);
    }

    private void scheduleNextPing() {
        if (!scheduler.isShutdown()) {
            scheduler.schedule(this::sendPing, 10, TimeUnit.SECONDS);
        }
    }

    public void sendPing() {
        if (this.isOpen() && authenticated) {
            JSONObject ping = new JSONObject();
            ping.put("event", "ping");
            this.send(ping.toString());
            System.out.println("Sent ping");
        }
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {
        System.out.println("Connection closed: " + reason);
        scheduler.shutdown();
    }

    @Override
    public void onError(Exception ex) {
        System.err.println("WebSocket error:");
        ex.printStackTrace();
    }

    public static void main(String[] args) throws Exception {
        URI uri = new URI("wss://ws.futurescw.com");
        SpotWebsocketPrivate client = new SpotWebsocketPrivate(
                uri,
                "YOUR API KEY",  // your api KEY
                "YOUR SECRET KEY" // your  secret KEY
        );
        client.connect();
    }
}

Authentication Type:​

Code Snippets​

RESTful Public Interface​

Python​

Java​

RESTful Private Interface​

Python​

Java​

Websocket Public Interface​

Python​

Method 1​

Method 2​

Java​

Method 1​

Method 2​

Websocket Private Interface​

Python​

Java​

Authentication Type:

Code Snippets

RESTful Public Interface

Python

Java

RESTful Private Interface

Python

Java

Websocket Public Interface

Python

Method 1

Method 2

Java

Method 1

Method 2

Websocket Private Interface

Python

Java