KuCoin API

https://www.kucoin.com/docs-new
Admin
KuCoin API provides programmatic access to KuCoin's cryptocurrency exchange services, enabling...
Tokens:527,660
Snippets:2,128
Trust Score:9.9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### User Information Example

Source: https://www.kucoin.com/docs-new/339001m0

Example of user API credentials used in the broker integration examples. These values are used in the signing and request header examples.

```java
String apikey = "api123key";
String apiSecretKey = "sec567key";
String passphrase = "1111111";
```

--------------------------------

### Go: KcSigner with Trade Fees and Limit Order Examples

Source: https://www.kucoin.com/docs-new/authentication

Go implementation of the Kucoin signer and example API calls. It defines KcSigner with HMAC-SHA256 signing, generates required headers (KC-API-KEY, KC-API-PASSPHRASE, KC-API-TIMESTAMP, KC-API-SIGN, KC-API-KEY-VERSION, X-SITE-TYPE), and demonstrates GET /api/v1/trade-fees and POST /api/v1/hf/orders. For a production-ready version, refer to the linked GitHub source.

```go
package main

import (
 "bytes"
 "crypto/hmac"
 "crypto/sha256"
 "encoding/base64"
 "encoding/json"
 "fmt"
 "github.com/google/uuid"
 "io"
 "net/http"
 "os"
 "strconv"
 "time"
)

type KcSigner struct {
 apiKey        string
 apiSecret     string
 apiPassPhrase string
}

func Sign(plain []byte, key []byte) []byte {
 hm := hmac.New(sha256.New, key)
 hm.Write(plain)
 data := hm.Sum(nil)
 return []byte(base64.StdEncoding.EncodeToString(data))
}

func (ks *KcSigner) Headers(plain string) map[string]string {
 t := strconv.FormatInt(time.Now().UnixNano()/1000000, 10)
 p := []byte(t + plain)
 s := string(Sign(p, []byte(ks.apiSecret)))
 ksHeaders := map[string]string{
  "KC-API-KEY":         ks.apiKey,
  "KC-API-PASSPHRASE":  ks.apiPassPhrase,
  "KC-API-TIMESTAMP":   t,
  "KC-API-SIGN":        s,
  "KC-API-KEY-VERSION": "3",
  "X-SITE-TYPE": "global"  /*
  Use "global" by default.
  Set to "australia" when accessing Australia site data or services.
  */
 }
 return ksHeaders
}

func NewKcSigner(key, secret, passPhrase string) *KcSigner {
 ks := &KcSigner{
  apiKey:        key,
  apiSecret:     secret,
  apiPassPhrase: string(Sign([]byte(passPhrase), []byte(secret))),
 }
 return ks
}

func getTradeFees(signer *KcSigner, client *http.Client) {
 endpoint := "https://api.kucoin.com"
 path := "/api/v1/trade-fees"
 method := "GET"
 queryParams := "symbols=BTC-USDT"

 fullURL := fmt.Sprintf("%s%s?%s", endpoint, path, queryParams)
 rawPath := fmt.Sprintf("%s?%s", path, queryParams)

 req, err := http.NewRequest(method, fullURL, nil)
 if err != nil {
  fmt.Println("Error creating request:", err)
  return
 }
 var b bytes.Buffer
 b.WriteString(method)
 b.WriteString(rawPath)
 b.Write([]byte{})

 headers := signer.Headers(b.String())
 for k, v := range headers {
  req.Header.Set(k, v)
 }
 resp, err := client.Do(req)
 if err != nil {
  fmt.Println("Error sending request:", err)
  return
 }
 defer resp.Body.Close()

 body, err := io.ReadAll(resp.Body)
 if err != nil {
  fmt.Println("Error reading response:", err)
  return
 }

 fmt.Println("Response:", string(body))
}

func addLimitOrder(signer *KcSigner, client *http.Client) {
 endpoint := "https://api.kucoin.com"
 path := "/api/v1/hf/orders"
 method := "POST"

 orderData := map[string]interface{}{
  "clientOid": uuid.NewString(),
  "side":      "buy",
  "symbol":    "BTC-USDT",
  "type":      "limit",
  "price":     "10000",
  "size":      "0.001",
 }

 orderDataBytes, err := json.Marshal(orderData)
 if err != nil {
  fmt.Println("Error marshalling order data:", err)
  return
 }

 fullURL := fmt.Sprintf("%s%s", endpoint, path)

 var b bytes.Buffer
 b.WriteString(method)
 b.WriteString(path)
 b.Write(orderDataBytes)

 req, err := http.NewRequest(method, fullURL, bytes.NewBuffer(orderDataBytes))
 if err != nil {
  fmt.Println("Error creating request:", err)
  return
 }

 headers := signer.Headers(b.String())
 for k, v := range headers {
  req.Header.Set(k, v)
 }

 req.Header.Set("Content-Type", "application/json")

 resp, err := client.Do(req)
 if err != nil {
  fmt.Println("Error sending request:", err)
  return
 }
 defer resp.Body.Close()

 body, err := io.ReadAll(resp.Body)
 if err != nil {
  fmt.Println("Error reading response:", err)
  return
 }

 fmt.Println("Response:", string(body))
}

func SignExample() {
 apiKey := os.Getenv("API_KEY")
 apiSecret := os.Getenv("API_SECRET")
 passphrase := os.Getenv("API_PASSPHRASE")

 signer := NewKcSigner(apiKey, apiSecret, passphrase)

 client := &http.Client{}

 getTradeFees(signer, client)
 addLimitOrder(signer, client)
}
```

--------------------------------

### Response examples for /margin/position (debt.ratio and position.status)

Source: https://www.kucoin.com/docs-new/3470078w0

Example response messages for the /margin/position channel. The first example shows a debt.ratio subject with debt ratio, asset and debt details. The second example shows a position.status subject with type FROZEN_FL and timestamp. Note: the second example incorrectly uses subject "debt.ratio" instead of "position.status".

```json
//"subject": "debt.ratio"
{
    "topic": "/margin/position",
    "subject": "debt.ratio",
    "type": "message",
    "userId": "633559791e1cbc0001f319bc",
    "channelType": "private"
    "data": {
        "debtRatio": 0,
        "totalAsset": 0.00052431772284080000000,
        "marginCoefficientTotalAsset": "0.0005243177228408",
        "totalDebt": "0",
        "assetList": {
            "BTC": {
                "total": "0.00002",
                "available": "0",
                "hold": "0.00002"
            },
            "USDT": {
                "total": "33.68855864",
                "available": "15.01916691",
                "hold": "18.66939173"
            }
        },
        "debtList": {
            "BTC": "0",
            "USDT": "0"
        },
        "timestamp": 1729912435657
    }
}

//"subject": "position.status"
{
    "topic": "/margin/position",
    "subject": "debt.ratio",
    "type": "message",
    "userId": "633559791e1cbc0001f319bc",
    "channelType": "private"
    "data": {
        "type": "FROZEN_FL",
        "timestamp": 15538460812100
    }
}
```

--------------------------------

### Go WebSocket Authentication and Connection

Source: https://www.kucoin.com/docs-new/websocket-api/introduction

Go example using the gorilla/websocket library to authenticate and connect to the KuCoin WebSocket API. It builds the authentication payload with HMAC-SHA256 signatures, sends it, and starts a goroutine to send ping messages every 20 seconds. Incoming messages are printed to the log.

```Go
package main
import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"encoding/json"
	"log"
	"strconv"
	"time"
	"github.com/gorilla/websocket"
)
const (
	apiKey        = "YOUR_API_KEY"
	apiSecret     = "YOUR_API_SECRET"
	apiPassphrase = "YOUR_API_PASSPHRASE"
	wsURL         = "wss://wsapi-push.kucoin.com"
)
func sign(plain []byte, key []byte) string {
	hash := hmac.New(sha256.New, key)
	hash.Write(plain)
	return base64.StdEncoding.EncodeToString(hash.Sum(nil))
}
func buildAuth() ([]byte, error) {
	timestamp := strconv.FormatInt(time.Now().UnixMilli(), 10)
	passphrase := sign([]byte(apiPassphrase), []byte(apiSecret))
	signature := sign(
		[]byte(timestamp+"POST/api/websocket/users/verify"),
		[]byte(apiSecret),
	)
	authReq := map[string]string{
		"op":                 "auth",
		"kc-api-key":         apiKey,
		"kc-api-passphrase":  passphrase,
		"kc-api-timestamp":   timestamp,
		"kc-api-sign":        signature,
	}
	return json.Marshal(authReq)
}
func main() {
	conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil)
	if err != nil {
		log.Fatal("Dial error:", err)
	}
	defer conn.Close()
	authMsg, err := buildAuth()
	if err != nil {
		log.Fatal("Build auth error:", err)
	}
	if err := conn.WriteMessage(websocket.TextMessage, authMsg); err != nil {
		log.Fatal("Write auth error:", err)
	}
	log.Println("Authentication request sent")
	go func() {
		ticker := time.NewTicker(20 * time.Second)
		defer ticker.Stop()
		for range ticker.C {
			if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
				log.Println("Ping error:", err)
				return
			}
		}
	}()
	for {
		_, message, err := conn.ReadMessage()
		if err != nil {
			log.Println("Read error:", err)
			break
		}
		log.Println("Received:", string(message))
	}
}
```

--------------------------------

### Install KuCoin skills non-interactively

Source: https://www.kucoin.com/docs-new/kucoin_skills_hub

Reruns the installation in non-interactive mode when it stops at the interactive skill selector. Adding --yes allows the installation to continue non-interactively.

```bash
npx skills add https://github.com/Kucoin/kucoin-skills-hub --full-depth --yes
```

--------------------------------

### PHP: Sign KuCoin API requests and fetch account summary

Source: https://www.kucoin.com/docs-new/authentication

Complete PHP example for signing KuCoin API requests and fetching account summary. The KcSigner class signs the passphrase and request payload using HMAC-SHA256, builds the required KC-API-* headers, and the httpRequest function performs the GET request via cURL. The main() function is for quick testing only; hardcoding secrets is unsafe and this example must not be used in production.

```php
<?php

class KcSigner
{
    private $apiKey;
    private $apiSecret;
    private $apiPassphrase;

    public function __construct(string $apiKey, string $apiSecret, string $apiPassphrase)
    {
        $this->apiKey = $apiKey ?: '';
        $this->apiSecret = $apiSecret ?: '';
        $this->apiPassphrase = $apiPassphrase ?: '';

        if ($apiSecret && $apiPassphrase) {
            $this->apiPassphrase = $this->sign($apiPassphrase, $apiSecret);
        }

        if (!$this->apiKey || !$this->apiSecret || !$this->apiPassphrase) {
            fwrite(STDERR, "Warning: API credentials are empty. Public endpoints only.\n");
        }
    }

    private function sign(string $plain, string $key): string
    {
        return base64_encode(hash_hmac('sha256', $plain, $key, true));
    }

    public function headers(string $payload): array
    {
        $timestamp = (string)(int)(microtime(true) * 1000);
        $signature = $this->sign($timestamp . $payload, $this->apiSecret);

        return [
            'KC-API-KEY' => $this->apiKey,
            'KC-API-PASSPHRASE' => $this->apiPassphrase,
            'KC-API-TIMESTAMP' => $timestamp,
            'KC-API-SIGN' => $signature,
            'KC-API-KEY-VERSION' => '3',
            'Content-Type' => 'application/json',
            // Set to "global" for KuCoin Global, or "australia" for KuCoin Australia.
            "X-SITE-TYPE" => "global"
        ];
    }
}

function processHeaders(KcSigner $signer, string $body, string $rawUrl, string $method): array
{
    $payload = $method . $rawUrl . $body;
    return $signer->headers($payload);
}

function httpRequest(string $method, string $url, array $headers, string $body = ''): array
{
    $curl = curl_init();
    if ($curl === false) {
        return ['status' => 0, 'body' => '', 'error' => 'Failed to initialize cURL'];
    }

    $headerLines = [];
    foreach ($headers as $key => $value) {
        $headerLines[] = $key . ': ' . $value;
    }

    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
    curl_setopt($curl, CURLOPT_HTTPHEADER, $headerLines);
    curl_setopt($curl, CURLOPT_TIMEOUT, 20);
    curl_setopt($curl, CURLOPT_CONNECTTIMEOUT, 10);

    if ($body !== '') {
        curl_setopt($curl, CURLOPT_POSTFIELDS, $body);
    }

    $respBody = curl_exec($curl);
    $curlError = curl_error($curl);
    $status = (int)curl_getinfo($curl, CURLINFO_HTTP_CODE);
    curl_close($curl);

    if ($respBody === false) {
        return ['status' => $status, 'body' => '', 'error' => $curlError];
    }

    return ['status' => $status, 'body' => $respBody, 'error' => ''];
}

function getAccountSummaryInfo(KcSigner $signer): void
{
    $endpoint = 'https://api.kucoin.com';
    $path = '/api/v2/user-info';
    $method = 'GET';
    $rawUrl = $path;
    $url = $endpoint . $rawUrl;

    $headers = processHeaders($signer, '', $rawUrl, $method);

    $resp = httpRequest($method, $url, $headers);
    if ($resp['error'] !== '') {
        echo "Error fetching account summary: " . $resp['error'] . PHP_EOL;
        return;
    }
    if ($resp['status'] >= 400 || $resp['status'] === 0) {
        echo "Error fetching account summary: HTTP " . $resp['status'] . " " . $resp['body'] . PHP_EOL;
        return;
    }

    echo $resp['body'] . PHP_EOL;
}

function main(): void
{
    // Fill in your API credentials here for quick testing.
    // NOTE: Hardcoding secrets in the main program is unsafe. This file is a
    // signing/verification example only and must NOT be used in production.
    $key = '';
    $secret = '';
    $passphrase = '';

    $signer = new KcSigner($key, $secret, $passphrase);

    getAccountSummaryInfo($signer);
}

if (php_sapi_name() === 'cli') {
    main();
}
?>
```

--------------------------------

### Funding Fee Settlement data example

Source: https://www.kucoin.com/docs-new/3470088w0

Example messages for the start and end of funding fee settlement. The 'subject' field indicates 'funding.begin' or 'funding.end', and the data includes symbol, fundingTime, fundingRate, and timestamp.

```json
//Start Funding Fee Settlement
{
  "topic": "/contract/announcement",
  "subject": "funding.begin",
  "data": {
    "symbol": "XBTUSDTM",
    "fundingTime": 1551770400000,
    "fundingRate": -0.002966,
    "timestamp": 1551770400000
  }
}
      
//End Funding Fee Settlement
{
  "type": "message",
  "topic": "/contract/announcement",
  "subject": "funding.end",
  "data": {
    "symbol": "XBTUSDTM",
    "fundingTime": 1551770400000,
    "fundingRate": -0.002966,
    "timestamp": 1551770410000
  }
}
```

--------------------------------

### Python: Initialize KcSigner and Load Credentials

Source: https://www.kucoin.com/docs-new/authentication

Python example that loads API credentials from environment variables, initializes a KcSigner with optional broker credentials, and shows commented-out calls for General API, Broker Pro, and Exchange Broker endpoints. Use this as a template for executing authenticated requests with the Kucoin Universal SDK.

```python
if __name__ == "__main__":
    # Load credentials
    # General API credentials (every user, including Broker Pro or Exchange Broker)
    key = os.getenv("API_KEY", "")
    secret = os.getenv("API_SECRET", "")
    passphrase = os.getenv("API_PASSPHRASE", "")

    # Broker credentials (if applicable)
    brokerName = os.getenv("KC-BROKER-NAME", "")
    brokerPartner = os.getenv("KC-API-PARTNER", "")
    brokerKey = os.getenv("BROKER-KEY", "")

    # Initialize signer and session
    session = requests.Session()
    signer = KcSigner(key, secret, passphrase, brokerPartner, brokerName, brokerKey)

    # Execute General API calls (if general API credentials are provided)
    # get_trade_fees(signer, session)
    # add_limit_order(signer, session)
    # add_futures_limit_order(signer, session)
    
    # Broker Pro calls (if Broker Pro credentials are provided)
    # query_broker_user(signer, session)

    # Exchange Broker calls (if Exchange Broker credentials are provided)
    # query_broker_info(signer, session)
```

--------------------------------

### Install all KuCoin skills

Source: https://www.kucoin.com/docs-new/kucoin_skills_hub

Installs all skills from the KuCoin Skills Hub into the current OpenClaw workspace. Requires --full-depth because skills are stored under skills/<name>/SKILL.md.

```bash
npx skills add https://github.com/Kucoin/kucoin-skills-hub --full-depth
```

--------------------------------

### Pagination API Request Example

Source: https://www.kucoin.com/docs-new/terms-definitions

Example of a GET request to /api/v2/orders with pagination parameters. The response includes currentPage, pageSize, totalNum, totalPage, and data fields. Default pageSize is 50, with a minimum of 10 and maximum of 500.

```http
GET /api/v2/orders?currentPage=1&pageSize=50
```

```json
{
  "currentPage": 1,
  "pageSize": 50,
  "totalNum": 6,
  "totalPage": 1,
  "data": ...
}
```

--------------------------------

### REST full order book snapshot example

Source: https://www.kucoin.com/docs-new/3470068w0

Example of the full order book snapshot obtained via REST (Get Full OrderBook) to build the local order book. The sequence field indicates the current snapshot sequence.

```json
...
"sequence": "16",
"asks":[
  ["3988.62","8"],//[Price, Size]
  ["3988.61","32"],
  ["3988.60","47"],
  ["3988.59","3"],
]
"bids":[
  ["3988.51","56"],
  ["3988.50","15"],
  ["3988.49","100"],
  ["3988.48","10"]
]
...
```

--------------------------------

### Add Order Response Example

Source: https://www.kucoin.com/docs-new/rest/spot-trading/orders/add-order?lang=en_US

Example response body for a successful order placement. Contains the trading system generated orderId and the user-defined clientOid.

```json
{"code":"200000","data":{"orderId":"670fd33bf9406e0007ab3945","clientOid":"5c52e11203aa677f33e493fb"}}
```

--------------------------------

### K-Line Data Update Message Example

Source: https://www.kucoin.com/docs-new/3470071w0

Example of the message received after subscribing to the K-Line topic. The data contains the symbol, an array of candle values (start time, open, close, high, low, volume, amount), and the current time in microseconds. The subject is trade.candles.update.

```json
{
    "topic": "/market/candles:BTC-USDT_1hour",
    "type": "message",
    "subject": "trade.candles.update",
    "data": {
        "symbol": "BTC-USDT", // symbol
        "candles": [
            "1729839600", // Start time of the candle cycle
            "67644.9", // open price
            "67437.6", // close price
            "67724.8", // high price
            "67243.8",  // low price
            "44.88321441",  // Transaction volume
            "3027558.991928447"  // Transaction amount
        ],
        "time": 1729842192785164840 // now（us）
    }
}
```

--------------------------------

### User Info Example

Source: https://www.kucoin.com/docs-new/rest/broker/instructions

Example API credentials for a user, including apikey, apiSecretKey, and passphrase.

```plaintext
String apikey = "6422da9c97b45100018c6e62";
String apiSecretKey = "cde06451-dbed";
String passphrase = "1111111";
```

--------------------------------

### K-Line Data Response Example

Source: https://www.kucoin.com/docs-new/3470086w0

Example of the message received after subscribing to the K-Line topic. The data contains the symbol and an array of candle values: start time, open, close, high, low, transaction volume (currently incorrect and should not be used), and transaction amount. The subject is 'candle.stick'.

```json
{
    "topic": "/contractMarket/limitCandle:XBTUSDTM_1min",
    "type": "message",
    "data": {
        "symbol": "XBTUSDTM",
        "candles": [
            "1731898200", //Start time of the candle cycle
            "90638.6",    //open price
            "90638.6",    //close price    
            "90638.6",    //high price
            "90638.6",    //low price
            "21.0",      //Transaction volume(This value is incorrect, please do not use it, we will fix it in subsequent versions)
            "21"         //Transaction amount
        ],
        "time": 1731898208357
    },
    "subject": "candle.stick"
}
```

--------------------------------

### GET /api/v1/contract/funding-rates

Source: https://www.kucoin.com/docs-new/rest/futures-trading/funding-fees/get-public-funding-history

This endpoint retrieves the funding rate history for a specified contract within a given time range. It requires the contract symbol and the start and end times in milliseconds.

```APIDOC
## [GET] /api/v1/contract/funding-rates

### Description
Query the funding rate at each settlement time point within a certain time range of the corresponding contract.

### Method
GET

### Endpoint
/api/v1/contract/funding-rates

### Parameters
#### Query Parameters
- **symbol** (string) - Required - Symbol of the contract. Please refer to [Get Symbol endpoint: symbol](https://www.kucoin.com/docs-new/rest/futures-trading/market-data/get-all-symbols.md)
- **from** (integer, int64) - Required - Begin time (milliseconds)
- **to** (integer, int64) - Required - End time (milliseconds)

### Request Example
GET /api/v1/contract/funding-rates?symbol=XBTUSDTM&from=1700310700000&to=1702310700000

### Response
#### Success Response (200)
- **code** (string) - Response code
- **data** (array) - List of funding rate records
  - **symbol** (string) - Symbol of the contract. Please refer to [Get Symbol endpoint: symbol](https://www.kucoin.com/docs-new/rest/futures-trading/market-data/get-all-symbols.md)
  - **fundingRate** (number) - Funding rate
  - **timepoint** (integer, int64) - Time point (milliseconds)

#### Response Example
{
  "code": "200000",
  "data": [
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.00021,
      "timepoint": 1702296000000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000347,
      "timepoint": 1702267200000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000452,
      "timepoint": 1702238400000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000513,
      "timepoint": 1702209600000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000421,
      "timepoint": 1702180800000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000506,
      "timepoint": 1702152000000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000768,
      "timepoint": 1702123200000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000482,
      "timepoint": 1702094400000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.0004,
      "timepoint": 1702065600000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000546,
      "timepoint": 1702036800000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000797,
      "timepoint": 1702008000000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000576,
      "timepoint": 1701979200000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000422,
      "timepoint": 1701950400000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000392,
      "timepoint": 1701921600000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.00041,
      "timepoint": 1701892800000
    },
    {
      "symbol": "XBTUSDTM",
      "fundingRate": 0.000448,
      "timepoint": 1701864000000
    }
  ]
}
```

--------------------------------

### Leverage Response Example

Source: https://www.kucoin.com/docs-new/3470237w0

Example of the real-time response data received when leverage is updated.

```json

{
  "T": "leverage.UNIFIED",
  "P": 1764570290237940700,
  "d": {
    "s": "XBTUSDTM",
    "l": "5.00"
    "mM":"CROSS"
    "tT":"FUTURES"

  }
{
  "T": "leverage.UNIFIED",
  "P": 1764570290237940710,
  "d": {
    "c": "BTC",
    "l": "5.00"
    "mM":"CROSS"
    "tT":"MARGIN"

  }
}
```

--------------------------------

### OBU Channel Response Examples for SPOT and FUTURES

Source: https://www.kucoin.com/docs-new/3470221w0

Example response messages for the OBU channel, covering SPOT and FUTURES with different depth types (bbo, increment, increment@10ms) and RPI filter. The 'O' and 'C' fields represent the starting and ending sequence numbers; for snapshot pushes they are always the same, while for incremental pushes they may differ.

```json
//SPOT-bbo  
{
    "T": "obu.SPOT",
    "dp": "1",
    "t": "snapshot",
    "P": 1768217874990007701,
    "d": {
        "C": 25984468414,
        "M": 1768217874986000000,
        "O": 25984468414,
        "a": [
            [
                "90701.2",
                "0.5771583"
            ]
        ],
        "b": [
            [
                "90701.1",
                "0.13918404"
            ]
        ],
        "s": "BTC-USDT"
    }
}
      
//SPOT-increment
{
    "T": "obu.SPOT",
    "dp": "increment",
    "t": "delta",
    "P": 1768217909684719896,
    "d": {
        "C": 25984544840,
        "M": 1768217909683000000,
        "O": 25984544839,
        "a": [],
        "b": [
            [
                "1",
                "12996.24994153"
            ]
        ],
        "s": "BTC-USDT"
    }
}

// SPOT-increment@10ms
{
    "T": "obu.SPOT",
    "dp": "increment@10ms",
    "t": "delta",
    "P": 1781672136338555550,
    "d": {
        "C": 33629695393,
        "M": 1781672136333000000,
        "O": 33629695388,
        "a": [],
        "b": [
            [
                "65928.9",
                "0"
            ],
            [
                "65946.6",
                "0"
            ],
            [
                "65947",
                "0.06185847"
            ]
        ],
        "s": "BTC-USDT"
    }
}
 
 
//FUTURES-bbo
{
    "T": "obu.FUTURES",
    "dp": "1",
    "t": "snapshot",
    "P": 1768217994549513415,
    "d": {
        "a": [
            [
                "90629.2",
                "2236"
            ]
        ],
        "b": [
            [
                "90629.1",
                "301"
            ]
        ],
        "s": "XBTUSDTM",
        "C": 1732420529826,
        "M": 1768217994548000000,
        "O": 1732420529826
    }
}
      
//FUTURES-increment
{
    "T": "obu.FUTURES",
    "dp": "increment",
    "t": "delta",
    "P": 1768218044321756061,
    "d": {
        "a": [
            [
                "90601.5",
                "0"
            ]
        ],
        "b": [],
        "C": 1732420557695,
        "s": "XBTUSDTM",
        "M": 1768218044321000000,
        "O": 1732420557695
    }
}

//FUTURES-increment@10ms
{
    "T": "obu.FUTURES",
    "dp": "increment@10ms",
    "t": "delta",
    "P": 1781666796660937177,
    "d": {
        "a": [],
        "b": [
            [
                "65739.9",
                "0"
            ],
            [
                "65739",
                "14"
            ]
        ],
        "C": 1743938538056,
        "s": "XBTUSDTM",
        "M": 1781666796658000000,
        "O": 1743938538050
    }
}
      
//FUTURES-RPI    
{
  "t" : "snapshot",
  "T" : "obu.FUTURES",
  "d" : {
    "O" : 1731931329201,
    "b" : [
      [
        "88862.4",
        "891",
        "0"
      ]
    ],
    "M" : 1767323800296000000,
    "s" : "XBTUSDTM",
    "a" : [
      [
        "88862.5",
        "1645",
        "0"
      ]
    ],
    "C" : 1731931329201
  },
  "P" : 1767323800305802104,
  "dp" : "5"
}
```

--------------------------------

### Install a specific KuCoin skill

Source: https://www.kucoin.com/docs-new/kucoin_skills_hub

Installs a single skill (e.g., spot) from the KuCoin Skills Hub into the current OpenClaw workspace. Use --skill <name> when only one skill is needed.

```bash
npx skills add https://github.com/Kucoin/kucoin-skills-hub --full-depth --skill spot
```

--------------------------------

### Order Info Example

Source: https://www.kucoin.com/docs-new/rest/broker/instructions

Example order request details including timestamp, URL, and body.

```plaintext
REQ TIMESTAMP: 1680885532722
REQ URL: https://api.kucoin.xxx/api/v1/orders
REQ BODY:{"symbol":"BTC-USDT","side":"buy","size":"0.0001","price":"30000","type":"limit","clientOid":"2b802154-8d31-42e6-88ea-c8c18d3e4822","tradeType":"TRADE"}
```

--------------------------------

### WS Request Example for op - uta.order

Source: https://www.kucoin.com/docs-new/3470344w0

Complete example of placing a limit order via WebSocket using op 'uta.order'. Shows the request with all required fields and the corresponding success response containing the orderId.

```json
// Add Request
{
    "args": {
        "clientOid": "313e793a-a88b-4311-a590-a3b3bac00d2f-8df",
        "orderType": "LIMIT",
        "postOnly": false,
        "price": "63310",
        "reduceOnly": false,
        "side": "BUY",
        "size": 1,
        "sizeUnit": "UNIT",
        "symbol": "XBTUSDTM",
        "tags": "KuCoin API Service",
        "timeInForce": "GTC",
        "tradeType": "FUTURES"
    },
    "id": "946ffd6b29904649b199a50885e114be",
    "op": "uta.order"
}

// Add Response
{
    "code": "200000",
    "data": {
        "clientOid": "313e793a-a88b-4311-a590-a3b3bac00d2f-8df",
        "orderId": "420781761635647489",
        "tradeType": "FUTURES",
        "ts": 1773135391743000000
    },
    "id": "946ffd6b29904649b199a50885e114be",
    "inTime": 1773135391711213000,
    "op": "uta.order",
    "outTime": 1773135391743642000
}
```

--------------------------------

### Order change message examples for /contractMarket/tradeOrders

Source: https://www.kucoin.com/docs-new/3470090w0

Example messages pushed for order changes. The 'Open' example shows a maker order placed in the order book. The 'Update' example shows a zero freeze cancel order update. The 'Match' example shows a maker match with status 'done'. The last example shows a taker match with tradeType 'liquid' and status 'match'.

```json
//Open
{
    "topic": "/contractMarket/tradeOrders:XBTUSDTM",
    "type": "message",
    "subject": "symbolOrderChange",
    "userId": "633559791e1cbc0001f319bc",
    "channelType": "private",
    "data": {
        "symbol": "XBTUSDTM",
        "tradeType": "trade",
        "side": "buy",
        "canceledSize": "0",
        "orderId": "247899236673269761",
        "liquidity": "maker",
        "marginMode": "ISOLATED",
        "type": "open",
        "orderTime": 1731916985768138917,
        "size": "1",
        "filledSize": "0",
        "price": "91670",
        "remainSize": "1",
        "status": "open",
        "ts": 1731916985789000000
    }
}
      
      
//Update
{
    "topic": "/contractMarket/tradeOrders",
    "type": "message",
    "subject": "orderChange",
    "userId": "669a61642857ca000186f626",
    "channelType": "private",
    "data": {
        "symbol": "RUNEUSDTM",
        "orderType": "limit",
        "tradeType": "trade",
        "side": "buy",
        "canceledSize": "1037",
        "orderId": "228685469427204099",
        "liquidity": "maker",
        "marginMode": "ISOLATED",
        "type": "update",
        "userId": "669a61642857ca000186f626",
        "oldSize": "19982",
        "orderTime": 1727336066682194084,
        "size": "19982",
        "filledSize": "0",
        "price": "5.029",
        "remainSize": "11618",
        "clientOid": "10496pp066R679264",
        "status": "open",
        "ts": 1727336066766000000
    }
}
      
//Match
{
    "topic": "/contractMarket/tradeOrders:XBTUSDTM",
    "type": "message",
    "subject": "symbolOrderChange",
    "userId": "633559791e1cbc0001f319bc",
    "channelType": "private",
    "data": {
        "symbol": "XBTUSDTM",
        "orderType": "limit",
        "tradeType": "trade",
        "side": "buy",
        "canceledSize": "0",
        "orderId": "247899236673269761",
        "liquidity": "maker",
        "marginMode": "ISOLATED",
        "type": "match",
        "feeType": "makerFee",
        "orderTime": 1731916985768138917,
        "size": "1",
        "filledSize": "1",
        "price": "91670",
        "matchPrice": "91670",
        "matchSize": "1",
        "remainSize": "0",
        "tradeId": "1794175373644",
        "status": "done",
        "ts": 1731916996762000000
    }
}
   
//Match - "tradeType": "liquid"
{
  "topic": "/contractMarket/tradeOrders:XBTUSDTM",
  "type": "message",
  "subject": "symbolOrderChange",
  "userId": "6356450****001cef524",
  "channelType": "private",
  "data": {
    "symbol": "XBTUSDTM",
    "orderType": "limit",
    "side": "sell",
    "canceledSize": "0",
    "orderId": "440761625608192",
    "liquidity": "taker",
    "marginMode": "ISOLATED",
    "type": "match",
    "feeType": "takerFee",
    "orderTime": 1743146786640000000,
    "size": "3840",
    "filledSize": "1116",
    "price": "84603.44",
    "matchPrice": "85739.69",
    "matchSize": "1000",
    "remainSize": "2724",
    "tradeId": "1740800012709",
    "tradeType": "liquid",
    "status": "match",
    "ts": 1743146786746000000
  }
}
```

--------------------------------

### Get Deposit History

Source: https://www.kucoin.com/docs-new/llms.txt

Get the deposit history.

```APIDOC
## [GET] /api/v1/deposit/history

### Description
Get the deposit history.

### Method
GET

### Endpoint
/api/v1/deposit/history

### Parameters
#### Query Parameters
- **currency** (string) - Optional - The currency to filter by.
- **startAt** (long) - Optional - Start time in milliseconds.
- **endAt** (long) - Optional - End time in milliseconds.

### Request Example
GET /api/v1/deposit/history?currency=BTC

### Response
#### Success Response (200)
- **code** (string) - Response code.
- **data** (array) - List of deposit records.

#### Response Example
{
  "code": "200000",
  "data": []
}
```

--------------------------------

### WS Request Example - margin.order

Source: https://www.kucoin.com/docs-new/3470252w0

WebSocket request example for placing a margin order.

```APIDOC
## WS Request Example

### Description
Example of a WebSocket request to add a margin order.

### Operation
`margin.order`

### Request Example
```json
{
    "args": {
        "clientOid": "6216aa42-894b-4cdc-94ac-7c46c6b976d4-78c",
        "symbol": "XBTUSDTM",
        "type": "limit",
        "side": "buy",
        "price": "70000",
        "size": 1,
        "leverage": 100,
        "marginMode": "ISOLATED",
        "positionSide": "LONG",
        "remark": "KuCoin_API_Service"
    },
    "id": "a3fffec107eb4d7bb4ed27f512fead23",
    "op": "margin.order"
}
```

### Response Example
```json
{
    "code": "200000",
    "data": {
        "borrowSize": null,
        "clientOid": "6216aa42-894b-4cdc-94ac-7c46c6b976d4-78c",
        "loanApplyId": null,
        "orderId": "69afda52f5c2aa00072ee487"
    },
    "id": "a3fffec107eb4d7bb4ed27f512fead23",
    "inTime": 1773132370563322000,
    "op": "margin.order",
    "outTime": 1773132370635998000
}
```
```
Tokens:
Raw