现货交易

以下部分概述了认证要求并提供访问现货API的代码示例。

认证类型：

接口类型	认证要求
RESTful公共接口	不需要认证
RESTful私有接口	需要API密钥和签名
Websocket公共接口	需要公共令牌
Websocket私有接口	需要API密钥和密钥

代码示例

RESTful公共接口

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私有接口

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公共接口

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私有接口

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();
    }
}

认证类型：​

代码示例​

RESTful公共接口​

Python​

Java​

RESTful私有接口​

Python​

Java​

Websocket公共接口​

Python​

Method 1​

Method 2​

Java​

Method 1​

Method 2​

Websocket私有接口​

Python​

Java​

认证类型：

代码示例

RESTful公共接口

Python

Java

RESTful私有接口

Python

Java

Websocket公共接口

Python

Method 1

Method 2

Java

Method 1

Method 2

Websocket私有接口

Python

Java