基本信息

API

使用API开发应用程序，您可以准确地获取Ktx现货市场的行情数据，快速进行自动化交易。API包含众多接口，按功能大致分为以下几组：

Market Data Endpoints 用于获取行情数据的REST接口
User Data Endpoints 用于获取用户私有数据的REST接口
Market Data Streams 用于获取行情数据的WebSocket接口
User Data Streams 用于获取用户私有数据的WebSocket接口

API使用如下Base URL：

Market Data Endpoints: https://api.ktx.com/api
User Data Endpoints: https://api-user.ktx.com/api
Market Data Stream: wss://stream-market.ktx.com
User Data Stream: wss://ktx-user.ktx.com

备用api域名列表

https://api.ktx.tel/v1/public/queryApiDomain

API的REST接口使用以下HTTP方法：

GET 用于获取行情或私有数据
POST 用于提交委托等操作

API的REST接口所需的参数应根据以下规则附加于请求中：

GET类型的接口参数应附加于Query String中
POST类型的接口参数应以JSON格式附加于Request Body中

Response

API的响应数据都以JSON格式返回，具体格式请参考各接口的描述。

Error

API的错误以如下JSON格式返回：

{
"state": error code,
"msg": "error message"
}

其中，state表示错误的类型，msg包含错误产生的原因或如何避免错误的提示。具体的错误类型请参考Error章节的内容。

Time or Timestamp

API接口参数和响应数据中所涉及的时间值都是UNIX时间，单位为毫秒。

流量限制

Ktx对来自于同一IP的请求做以下访问限制:

Access Limits 访问频率限制
Usage Limits CPU用量限制

Access Limits访问频率限制
1. 同一IP每10秒最多10000次请求，超出限制的请求会收到-20007错误。
2. 用户可以根据需要在10秒内以任意频率发送最多10000次请求，可以大约每10ms发送一次，也可以在1秒内连续发送10000次，然后等待9秒。
Usage Limits用量限制
1. 同一IP每10秒最多消耗10000点CPU 时间，超出限制的请求会收到-20006错误。
2. 不同API消耗的CPU时间不同，这取决于API如何访问数据。
3. 在本文中, 每个API接口访问数据的方式会以“缓存”, “数据库”的形式标明。访问缓存的API消耗的CPU时间较少，访问数据库的API消耗的CPU时间较多。根据用户发送的参数，API可能混合访问缓存和数据库，甚至多次访问数据库，这会增加API消耗的CPU时间。
4. 每次API请求消耗的CPU时间会包含在响应头Ktx-Usage中，其格式为t1:t2:t3，其中，t1表示本次API请求消耗的CPU时间，t2表示最近10秒内当前IP消耗的CPU时间，t3表示最近10秒内当前IP剩余的可用CPU时间。

认证

完整例子

let CryptoJS = require("crypto-js");
let request = require("request");

const endpoints = 'https://api-user.ktx.com/api'
const apikey = "9e03e8fda27b6e4fc6b29bb244747dcf64092996"; // your apikey
const secret = "b825a03636ca09c884ca11d71cfc4217a98cb8bf"; // your secret


const queryStr = 'asset=BTC';
const sign = CryptoJS.HmacSHA256(queryStr, secret).toString(); // POST or DELETE  replace queryStr with bodyStr
const url = `${endpoints}/v1/accounts?${queryStr}`;

request.get(url,{
          headers: {
            'Content-Type': 'application/json',
            'api-key': apikey,
            'api-sign': sign,
            'api-expire-time':Date.now()+5000 // optional
          },
        },

        function optionalCallback(err, httpResponse, body) {
          if (err) {
            return console.error('upload failed:', err);
          }
          console.log(body) // 7.the result

        });

import hashlib
import hmac
import requests

END_POINT = 'https://api-user.ktx.com/api'
API_KEY = '9e03e8fda27b6e4fc6b29bb244747dcf64092996'
SECRET_KEY = 'b825a03636ca09c884ca11d71cfc4217a98cb8bf'


def do_request():
    path = '/v1/accounts'
    query_str = 'asset=BTC'
    # POST or DELETE replace query_str with body_str
    sign = hmac.new(SECRET_KEY.encode("utf-8"), query_str.encode("utf-8"), hashlib.sha256).hexdigest()

    headers = {
        'Content-Type': 'application/json',
        'api-key': API_KEY,
        'api-sign': sign,
    }
    resp = requests.get(END_POINT + path, query_str, headers=headers)
    print(resp.text)


if __name__ == '__main__':
    do_request()

身份验证

私有接口用于访问账户、委托等私有信息，在请求时需要附加签名，以满足Ktx进行身份验证。本节将描述如何创建签名。

生成Api Key

要创建签名，首先需要生成Api Key和Secret Key组合。请牢记在此过程中生成的Secret Key，因为该值仅显示一次，如果忘记了Secret Key，请删除该Api Key，并生成新的Api Key和Secret Key组合。

HTTP 请求头

访问私有接口的请求都必需附加以下HTTP请求头：

api-key 已生成的Api Key
api-sign 签名

如果需要，也可以附加以下HTTP请求头：

api-expire-time
1. 接口过期时间。
2. 该值是以毫秒为单位的Unix时间，服务器会忽略该时间之后收到的请求，这主要用于避免网络延迟带来的影响。

创建签名

在发送请求前，首先确定用于签名的消息体。对于GET类型的请求，Query String是需要签名的消息体，对于POST请求，Body String是需要签名的消息体。签名的具体方法如下：

第一步：以Secret Key作为Key对需要签名的消息体执行HmacSHA256算法
第二步：将以上结果转化为Hex String
第三步：将Hex String作为请求头api-sign的值

Api Key权限

私有接口需要特定的权限才能执行。可以为Api Key授予适当的权限。如果Api Key未被授予某个接口需要的权限，那么使用该Api Key提交的请求将被拒绝。

可以授予Api Key以下权限：

View权限允许Api Key获取私有数据。
Trade权限允许Api Key提交或撤销委托，并允许Api Key获取交易相关的数据。

接口需要的权限将在每个接口的描述中给出。

Market Data Endpoints

获取交易对

Request

let request = require("request");
const endPoint = 'https://api.ktx.com/api';
const url = `${endPoint}/v1/products?market=spot&symbol=BTC_USDT`
request.get(url,
        function optionalCallback(err, httpResponse, body) {
          if (err) {
            return console.error('failed:', err);
          }

          console.log(body)

        });

import requests

END_POINT = 'https://api.ktx.com/api';

def do_request():
    path = '/v1/products?market=spot&symbol=BTC_USDT'
    resp = requests.get(END_POINT + path)
    print(resp.text)

if __name__ == '__main__':
    do_request()

Response

[
  {
    "id": 5 // id
    "market": "lpc", // spot or lpc 现货或者合约
    "symbol": "BTC_USDT_SWAP", // 交易对
    "takerFee": "0.001", // taker手续费
    "makerFee": "0.001", // maker 手续费
    "minOrderSize": "0.0001", // 最小下单数量
    "maxOrderSize": "10000000",// 最大下单数量
    "quantityScale": 4, // 数量精度
    "priceScale": 4, // 价格精度
    "minOrderValue": "0.0001", // 最小下单价值
    "maxOrderValue": "10000000000", // 最大下单价值
    "fundingRate": "0.0001" // 资金费率
    "nextFundingTime": "1733472000000", // 资金费率结算时间
    "predictedFundingRate": "0.0001", // 预期资金费率
    "markPrice": "98042.3405", // 标记价格
  }
]

获取币种列表

请求方式 GET
请求路径 /v1/products
请求参数

参数名称	参数类型	是否必传	说明
market	string	是	交易对市场，如 spot, lpc 等，spot为现货,lpc为U本位合约
symbol	string	否	交易对代码，如 BTC_USDT, ETH_USDT 等，不指定返回全部交易对

Data source

Cache

获取订单薄

Request

let request = require("request");
const endPoint = 'https://api.ktx.com/api';
const url = `${endPoint}/v1/order_book?market=spot&symbol=BTC_USDT`
request.get(url,
        function optionalCallback(err, httpResponse, body) {
          if (err) {
            return console.error('upload failed:', err);
          }

          console.log(body)

        });

import requests

END_POINT = 'https://api.ktx.com/api';

def do_request():
    path = '/v1/order_book?market=spot&symbol=BTC_USDT'
    resp = requests.get(END_POINT + path)
    print(resp.text)

if __name__ == '__main__':
    do_request()

Response

{
  "i": "1027024", // update id
  "t": "1644558642100", // update time
  "b": [ // 买盘
    [
      "46125.7", // 委托价格
      "0.079045" // 委托量
    ],
    [
      "46125.7", // 委托价格
      "0.079045" // 委托量
    ],
    [
      "46125.7", // 委托价格
      "0.079045" // 委托量
    ]
    ...
  ],
  "a": [ // 卖盘
    [
      "46125.7", // 委托价格
      "0.079045" // 委托量
    ],
    [
      "46125.7", // 委托价格
      "0.079045" // 委托量
    ],
    [
      "46125.7", // 委托价格
      "0.079045" // 委托量
    ]
    ...
  ]
}

获取深度数据

请求方式 GET
请求路径 /v1/order_book
请求参数

参数名称	参数类型	是否必传	说明
market	string	是	交易对市场，如 spot, lpc 等，spot为现货,lpc为U本位合约
symbol	string	是	交易对代码，如 BTC_USDT, ETH_USDT 等
level	int32	否	指定最多返回多少级深度有效值 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000 默认值 100
price_scale	integer	否	指定按价格合并深度，如指定交易对的价格最多含4位小数 price_scale=0 时返回的价格最多含4位小数, price_scale=1 时返回的价格最多含3位小数, 委托量是价格区间0.0010中全部委托量的和 price_scale=2 时返回的价格最多含2位小数, 委托量是价格区间0.0100中全部委托量的和 price_scale=3 时返回的价格最多含1位小数, 委托量是价格区间0.1000中全部委托量的和 price_scale=4 时返回的价格最多含0位小数, 委托量是价格区间1.0000中全部委托量的和有效值 0, 1, 2, 3, 4, 5 默认值 0

注意: 数据按价格最优排序, 即买侧深度按价格由大到小排序, 卖侧深度按价格由小到大排序

Data source

Cache

获取K线

Request

let request = require("request");
const endPoint = 'https://api.ktx.com/api';
const url = `${endPoint}/v1/candles?market=spot&symbol=BTC_USDT&time_frame=1m`
request.get(url,
        function optionalCallback(err, httpResponse, body) {
          if (err) {
            return console.error('upload failed:', err);
          }

          console.log(body)

        });

import requests

END_POINT = 'https://api.ktx.com/api';

def do_request():
    path = '/v1/candles?market=spot&symbol=BTC_USDT&time_frame=1m'
    resp = requests.get(END_POINT + path)
    print(resp.text)

if __name__ == '__main__':
    do_request()

Response

{
  "t": 60000, // 时间周期
  "e": [
    [
      "1644224940000", // 起始时间
      "10190.53", // 开盘价格
      "10192.5", // 最高价格
      "9806.82", // 最低价格
      "10127.37", // 收盘价格
      "0.834", // 成交量
      "8370.40506", // 成交价值
      "1", // 首个成交的id
      278 // 区间内总成交次数
    ],
    [
      "1644224940000",
      "10190.53",
      "10192.5",
      "9806.82",
      "10127.37",
      "0.834",
      "8370.40506",
      "1",
      278
    ],
    ...
  ]
}

获取K线数据

请求方式 GET
请求路径 /v1/candles
请求参数

参数名称	参数类型	是否必传	说明
market	string	是	交易对市场，如 spot, lpc 等，spot为现货,lpc为U本位合约
symbol	string	是	交易对代码，如 BTC_USDT, ETH_USDT 等
time_frame	string	是	K线数据的时间周期有效值 1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h, 12h, 1d, 3d, 1W或1M
before	int64	否	utc时间限定返回K线记录的最近时间
after	int64	否	utc时间限定返回K线记录的最早时间
limit	integer	否	获取K线记录的最大数量默认值100，最大值1000

该接口支持的参数组合和数据源

symbol + time_frame --> cache
symbol + time_frame + limit --> cache
symbol + time_frame + before --> database
symbol + time_frame + before + limit --> database
symbol + time_frame + after --> database
symbol + time_frame + after + limit --> database

返回结果按时间由早及近排序

获取成交记录

Request

let request = require("request");
const endPoint = 'https://api.ktx.com/api';
const url = `${endPoint}/v1/trades?market=spot&symbol=BTC_USDT`
request.get(url,
        function optionalCallback(err, httpResponse, body) {
          if (err) {
            return console.error('upload failed:', err);
          }

          console.log(body)

        });

import requests

END_POINT = 'https://api.ktx.com/api';

def do_request():
    path = '/v1/trades?market=spot&symbol=BTC_USDT'
    resp = requests.get(END_POINT + path)
    print(resp.text)

if __name__ == '__main__':
    do_request()

Response

[
  {
    "i": "17122255", // 交易 id
    "p": "46125.7", // 成交价格
    "q": "0.079045", // 成交量
    "s": "1", // Taker 的成交方向 1代表买 -1代表卖
    "t": "1628738748319" // 成交时间
  },
  {
    "i": "17122255", // 交易 id
    "p": "46125.7", // 成交价格
    "q": "0.079045", // 成交量
    "s": "-1", // Taker 的成交方向 1代表买 -1代表卖
    "t": "1628738748319" // 成交时间
  },
  {
    "i": "17122255", // 交易 id
    "p": "46125.7", // 成交价格
    "q": "0.079045", // 成交量
    "s": "1", // Taker 的成交方向 1代表买 -1代表卖
    "t": "1628738748319" // 成交时间
  }
  ...
]

获取交易记录

请求方式 GET
请求路径 /v1/trades
请求参数

参数名称	参数类型	是否必传	说明
market	string	是	交易对市场，如 spot, lpc 等，spot为现货,lpc为U本位合约
symbol	string	是	交易对代码，如 BTC_USDT, ETH_USDT 等
start_time	int64	否	限定返回交易记录的最早时间
end_time	int64	否	限定返回交易记录的最近时间
before	int64	否	交易记录 id 限定返回交易记录的最大id
after	int64	否	交易记录 id 限定返回交易记录的最大id
limit	integer	否	获取记录的最大数量默认值100，最大值1000

该接口支持的参数组合和数据源

symbol --> cache
symbol + limit --> cache
symbol + start_time --> database
symbol + start_time + limit --> database
symbol + end_time --> database
symbol + end_time + limit --> database
symbol + start_time + end_time --> database
symbol + start_time + end_time + limit --> database
symbol + before --> database
symbol + before + limit --> database
symbol + after --> database
symbol + after + limit --> database

数据源为cache的参数组合用于获取最近1000条交易记录

数据源为database的参数组合用于获取较早的交易记录

如果用数据源为database的参数组合获取最新交易记录，其结果要比cache数据源稍有延迟 * Usage 用法举例：获取三个月内某交易对的全部交易记录

首先使用symbol + limit 参数组合获取最新的交易记录
将取到的首条记录的tradeId作为before参数的值，反复使用symbol + before + limit参数组合获取更多记录，直至获取三个月内的全部交易记录后停止

返回结果按交易记录id由小到大排序

获取 Tickers

Request

let request = require("request");
const endPoint = 'https://api.ktx.com/api';
const url = `${endPoint}/v1/ticker?market=spot&symbol=BTC_USDT`
request.get(url,
        function optionalCallback(err, httpResponse, body) {
          if (err) {
            return console.error('upload failed:', err);
          }

          console.log(body)

        });

import requests

END_POINT = 'https://api.ktx.com/api';

def do_request():
    path = '/v1/ticker?market=spot&symbol=BTC_USDT'
    resp = requests.get(END_POINT + path)
    print(resp.text)

if __name__ == '__main__':
    do_request()

Response

[
  {
    "askPrice": "98100", // 卖一价
    "product": "BTC_USDT", // 交易对
    "amount": "922635", // 24成交价值
    "last": "98000", // 最新成交价
    "firstTradeId": 1, // 第一笔交易id
    "change": "0", // 价格变化
    "bidQty": "1.7", // 卖一数量
    "bidPrice": "98000", // 买一价
    "volume": "9.41", // 24h成交数量
    "lastQty": "0.3", // 24h最新成交
    "askQty": "0.5", // 卖一数量
    "high": "98100", // 24最高价
    "tradeCount": 30, // 成交次数
    "low": "98000", // 24h最低价
    "time": "1733474204000", // 时间
    "open": "98000" // 开盘价格
  }
]

获取报价数据

请求方式 GET
请求路径 /v1/ticker
请求参数

参数名称	参数类型	是否必传	说明
market	string	是	交易对市场，如 spot, lpc 等，spot为现货,lpc为U本位合约
symbol	string	是	交易对代码，如 BTC_USDT, ETH_USDT 等，可按如下两种形式指定多个交易对代码 1. symbol=BTC_USDT,ETH_USDT

Data Source

Cache

Market Data 推送

Overview

例子

const WebSocket = require('ws');
const ktxws = 'wss://stream-market.ktx.com';

let wsClass = function () {
};

wsClass.prototype._initWs = async function () {
    let that = this;
    console.log(ktxws)
    let ws = new WebSocket(ktxws);
    that.ws = ws;

    ws.on('open', function open() {
        console.log(new Date(), 'open')
        ws.send(JSON.stringify({"method":"SUBSCRIBE","params":["spot.BTC_USDT.order_book.5"]}));
        setInterval(function () {
          ws.ping(Date.now())
        },30000)
    });

    ws.on('close', data => {
        console.log('close, ', data);
    });

    ws.on('error', data => {
        console.log('error', data);
    });

    ws.on('ping', data => {
        console.log('ping ', data.toString('utf8'));
    });

    ws.on('pong', data => {
        console.log('pong ', data.toString('utf8'));
    });

    ws.on('message', data => {
        console.log("rece message")
        console.log(data)
    });
};

let instance = new wsClass();

instance._initWs().catch(err => {
    console.log(err);
});

import websocket
import json

ws_url = 'wss://stream-market.ktx.com'

def stringify(obj):
    return json.dumps(obj, sort_keys=True).replace("\'", "\"").replace(" ", "")


def get_sub_str():
    subdata = {"method":"SUBSCRIBE","params":["spot.BTC_USDT.order_book.5"]} 
    return stringify(subdata)


def on_message(ws, message):
    print(message)


def on_error(ws, error):
    print(error)


def on_close(ws):
    print("### closed ###")


def on_open(ws):
    ws.send(get_sub_str())


def connect():
    # websocket.enableTrace(True)
    ws = websocket.WebSocketApp(ws_url,
                                on_message=on_message,
                                on_error=on_error,
                                on_close=on_close)
    ws.on_open = on_open
    ws.run_forever(ping_interval=30, ping_timeout=5)


if __name__ == "__main__":
    connect()

使用 Websocket 推送服务可以及时获取行情信息。

连接 Websocket 服务器请使用以下 URL 连接 Websocket 服务器：
wss://stream-market.ktx.com

在连接后，客户端可以发送以下JSON格式的请求给服务器

{
  "id": 123, // 由客户端给定的请求id
  "method":"SUBSCRIBE", // 请求类型
  "params":["spot.BTC_USDT.order_book.5"]
}

在收到请求后，服务器会发送以下JSON格式的响应给客户端

{
  "result":"success", // 返回结果
  "op":"SUBSCRIBE", 
  "id": 123, // 由客户端给定的请求id
  "events":["spot.BTC_USDT.order_book.5"]
}

如果发生错误，服务器会发送以下错误信息给客户端

{
  "id": 123, // 请求id
  "error": -1003, // 错误代码
  "message": "..." // 错误描述
}

同时，服务器还会发送以下JSON格式的数据流给客户端, 数据流包含市场行情的变化信息

{
  "stream": "spot.BTC_USDT.order_book.5", // 数据流名称
  "data": ..., // 数据
}

请求：订阅数据流

{
  "id": 1,
  "method": "SUBSCRIBE",
  "params": [
    "stream name",
    "stream name",
    ...
  ]
}

在连接后，请首先发送该请求给服务器，随后，服务器会在行情变化时发送相应的数据流给客户端。

"data stream name" 是数据流名称，数据流名称是以下格式的字符串。 market.symbol.data_type.param1.param2...

其中，market是交易对市场，如spot和lpc symbol是交易对名称，如 BTC_USDT、ETH_USDT 等。 data_type是数据类型，目前仅支持以下数据类型 order_book: 深度 trades: 交易列表 candles: K线 ticker: 最新成交信息

在data_type之后是参数列表，不同的数据类型有不同的参数列表，这些将在后续介绍

请求: 取消订阅数据流

{
  "id": 1,
  "method": "UNSUBSCRIBE",
  "params": [
    "data stream name",
    "data stream name",
    ...
  ]
}

如果请求被服务器正确处理，客户端会收到以下响应:

  {
    "result":"success", // 返回结果
    "op":"SUBSCRIBE",
    ... 
    }

如果请求出错，客户端会收到以下错误响应:

{
  "error": -1003, // 错误代码
  "message": "..." // 错误描述
}

请求类型及参数

请求类型及参数

客户端可以发送以下请求给服务器

{
  "id": 123, // 由客户端给定的请求id
  "method": "..." // 请求类型
  "params": [ // 请求参数列表
    "...",
    "...",
  ]
}

其中method字段的值是以下请求类型之一:

可选值	说明
SUBSCRIBE	1.订阅数据流 2.参数是数据流名称列表 3.在成功订阅后，服务器会在行情发生变化时发送数据流给客户端
UNSUBSCRIBE	1.取消订阅数据流 2.参数是数据流名称列表 3.在成功取消订阅后，客户端不会再收到相应的数据流

订阅深度信息

订阅深度信息

发送以下请求可订阅深度信息

{
  "id": 123,
  "method": "SUBSCRIBE",
  "params": [
    "spot.BTC_USDT.order_book.20",
    "spot.ETH_USDT.order_book.20",
    ...
  ]
}

参数

该请求的参数是深度流名称，格式如下：

<market><symbol>.order_book.<max_depth>
1. <market> 是交易对市场，如spot，lpc
2. <symbol> 是交易对名称，如BTC_USDT，ETH_USDT等
3. <max_depth> 是最大深度，有效值是5, 10, 20, 50, 100, 200, 500, 1000

数据流

  {
    "stream": "spot.BTC_USDT.order_book.20",
    "data": {
      "i": "1027024", // update id
      "t": "1644558642100", // update time
      "b": [ // 买盘
        [
            "46125.7", // 委托价格
            "0.079045" // 委托量
          ],
        [
            "46125.7", // 委托价格
            "0.079045" // 委托量
          ],
        [
            "46125.7", // 委托价格
            "0.079045" // 委托量
          ],
        ...
      ],
      "a": [ // 卖盘
        [
            "46125.7", // 委托价格
            "0.079045" // 委托量
          ],
        [
            "46125.7", // 委托价格
            "0.079045" // 委托量
          ],
        [
            "46125.7", // 委托价格
            "0.079045" // 委托量
          ],
       ...
      ]
    }
  }

在成功订阅后，客户端会首先收到一个完整深度的数据流，之后会收到增量变化数据流，请按以下方法合成完整的深度，或使用SDK.

...

订阅交易列表

订阅交易列表

发送以下请求可订阅交易列表

{
  "id": 123,
  "method": "SUBSCRIBE"
  "params": [
    "spot.BTC_USDT.trades",
    "spot.ETH_USDT.trades",
    ...
  ]
}

参数

该请求的参数是交易流名称，格式如下：

<market><symbol>.trades
1. <market> 是交易对市场，如spot，lpc
2. <symbol> 是交易对名称，如BTC_USDT，ETH_USDT等

数据流

{
  "stream": "spot.BTC_USDT.trades",
  "data": [
    {
      "i": "17122255", // 交易 id
      "p": "46125.7", // 成交价格
      "q": "0.079045", // 成交量
      "s": "buy", // Taker 的成交方向
      "t": "1628738748319" // 成交时间
    },
    {
      "i": "17122255", // 交易 id
      "p": "46125.7", // 成交价格
      "q": "0.079045", // 成交量
      "s": "buy", // Taker 的成交方向
      "t": "1628738748319" // 成交时间
    },
    {
      "i": "17122255", // 交易 id
      "p": "46125.7", // 成交价格
      "q": "0.079045", // 成交量
      "s": "buy", // Taker 的成交方向
      "t": "1628738748319" // 成交时间
    },
    ...
  ]
}

订阅K线

订阅K线

发送以下请求可订阅K线

{
  "id": 123,
  "method": "SUBSCRIBE"
  "params": [
    "spot.BTC_USDT.candles.1m",
    "spot.ETH_USDT.candles.1h",
    ...
  ]
}

参数

K线流名称格式如下：

<market><symbol>.candles.<time_frame>
1. <market> 是交易对市场，如spot，lpc
2. <symbol> 是交易对名称，如BTC_USDT，ETH_USDT等
3. <time_frame> 是K线周期，有效值是1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h, 12h, 1d, 1w, 1M > 数据流

{
  "stream": "spot.BTC_USDT.candles.1m",
  "data": {
      "t":60000, // 时间周期
      "e":[
      [
        "1644224940000", // 起始时间
        "10190.53", // 开盘价格
        "10192.5", // 最高价格
        "9806.82", // 最低价格
        "10127.37", // 收盘价格
        "0.834", // 成交量
        "8370.40506", // 成交价值
        "1", // 首个成交的id
        278 // 区间内总成交次数
      ],
      [
        "1644224940000", // 起始时间
        "10190.53", // 开盘价格
        "10192.5", // 最高价格
        "9806.82", // 最低价格
        "10127.37", // 收盘价格
        "0.834", // 成交量
        "8370.40506", // 成交价值
        "1", // 首个成交的id
        278 // 区间内总成交次数
      ],
      [
        "1644224940000", // 起始时间
        "10190.53", // 开盘价格
        "10192.5", // 最高价格
        "9806.82", // 最低价格
        "10127.37", // 收盘价格
        "0.834", // 成交量
        "8370.40506", // 成交价值
        "1", // 首个成交的id
        278 // 区间内总成交次数
      ],
      ...
    ]}
  }
}

订阅ticker

订阅ticker

发送以下请求可订阅Ticker

{
  "id": 123,
  "method": "SUBSCRIBE"
  "params": [
    "spot.BTC_USDT.ticker",
    "spot.ETH_USDT.ticker",
    ...
  ]
}

参数

Ticker流名称格式如下：

<market><symbol>.ticker
1. <market> 是交易对市场，如spot，lpc
2. <symbol> 是交易对名称，如BTC_USDT，ETH_USDT等 > 数据流

{
  "stream": "spot.BTC_USDT.ticker",
  "data": {   
    "askPrice": "98100", // 卖一价
    "product": "BTC_USDT", // 交易对
    "amount": "922635", // 24成交价值
    "last": "98000", // 最新成交价
    "firstTradeId": 1, // 第一笔交易id
    "change": "0", // 价格变化
    "bidQty": "1.7", // 卖一数量
    "bidPrice": "98000", // 买一价
    "volume": "9.41", // 24h成交数量
    "lastQty": "0.3", // 24h最新成交
    "askQty": "0.5", // 卖一数量
    "high": "98100", // 24最高价
    "tradeCount": 30, // 成交次数
    "low": "98000", // 24h最低价
    "time": "1733474204000", // 时间
    "open": "98000" // 开盘价格
  }
}

User Data Endpoints

获取账户信息

Request

let CryptoJS = require("crypto-js");
let request = require("request");

const endpoints = 'https://api-user.ktx.com/api'
const apikey = "9e03e8fda27b6e4fc6b29bb244747dcf64092996"; // your apikey
const secret = "b825a03636ca09c884ca11d71cfc4217a98cb8bf"; // your secret


const queryStr = 'asset=BTC';
const sign = CryptoJS.HmacSHA256(queryStr, secret).toString();
const url = `${endpoints}/v1/accounts?${queryStr}`;

request.get(url,{
          headers: {
            'Content-Type': 'application/json',
            'api-key': apikey,
            'api-sign': sign,
            'api-expire-time':Date.now()+5000 // optional
          },
        },

        function optionalCallback(err, httpResponse, body) {
          if (err) {
            return console.error('upload failed:', err);
          }
          console.log(body) // 7.the result

        });

import hashlib
import hmac
import requests

END_POINT = 'https://api-user.ktx.com/api'
API_KEY = '9e03e8fda27b6e4fc6b29bb244747dcf64092996'
SECRET_KEY = 'b825a03636ca09c884ca11d71cfc4217a98cb8bf'


def do_request():
    path = '/v1/accounts'
    query_str = 'asset=BTC'
    sign = hmac.new(SECRET_KEY.encode("utf-8"), query_str.encode("utf-8"), hashlib.sha256).hexdigest()

    headers = {
        'Content-Type': 'application/json',
        'api-key': API_KEY,
        'api-sign': sign,
    }
    resp = requests.get(END_POINT + path, query_str, headers=headers)
    print(resp.text)


if __name__ == '__main__':
    do_request()

Response

[
  {
    "asset":"USDT",  // 资产代码
    "balance":10000,  // 总额
    "holds":0  // 冻结额
  },
  {
    "asset":"USDT",  // 资产代码
    "balance":10000,  // 总额
    "holds":0  // 冻结额
  },
  ...
]

获取 API Key 对应账户中各种资产的余额, 冻结等信息

请求方式 GET
请求路径 /v1/accounts
权限: View, Trade
请求参数

参数名称	参数类型	是否必传	说明
asset	string	否	资产代码，如 BTC, ETH 等可按以下两种形式指定多个资产代码 1. /v1/accounts?asset=BTC,ETH 2. /v1/accounts?asset=BTC&asset=ETH 如果不指定 asset 参数, 则返回全部资产的信息

Data Source

Cache

获取账单

Request

let CryptoJS = require("crypto-js");
let request = require("request");

const endpoints = 'https://api-user.ktx.com/api'
const apikey = "9e03e8fda27b6e4fc6b29bb244747dcf64092996"; // your apikey
const secret = "b825a03636ca09c884ca11d71cfc4217a98cb8bf"; // your secret


const queryStr = 'asset=BTC&end_time=1651895799668&limit=10';
const sign = CryptoJS.HmacSHA256(queryStr, secret).toString();
const url = `${endpoints}/v1/ledger?${queryStr}`;

request.get(url,{
        headers: {
            'Content-Type': 'application/json',
            'api-key': apikey,
            'api-sign': sign,
            'api-expire-time':Date.now()+5000 // optional
        },
    },

    function optionalCallback(err, httpResponse, body) {
        if (err) {
            return console.error('upload failed:', err);
        }
        console.log(body) // 7.the result

    });

import hashlib
import hmac
import requests

END_POINT = 'https://api-user.ktx.com/api'
API_KEY = '9e03e8fda27b6e4fc6b29bb244747dcf64092996'
SECRET_KEY = 'b825a03636ca09c884ca11d71cfc4217a98cb8bf'


def do_request():
    path = '/v1/ledger'
    query_str = 'asset=BTC&end_time=1651895799668&limit=10'
    sign = hmac.new(SECRET_KEY.encode("utf-8"), query_str.encode("utf-8"), hashlib.sha256).hexdigest()

    headers = {
        'Content-Type': 'application/json',
        'api-key': API_KEY,
        'api-sign': sign,
    }
    resp = requests.get(END_POINT + path, query_str, headers=headers)
    print(resp.text)


if __name__ == '__main__':
    do_request()

Response

[
  {
    "amount":"10000",   // 变化数量
    "balance":"10000",  // 余额
    "id":"1125899906842624029", // id
    "time":"1733468814795", // 时间
    "asset":"USDT",   // 资产代码
    "type":"transfer" // 账单类型
  }
  ...
]

获取 API Key 对应账户的账单，包含一切改变账户余额的记录，如资金划转、交易、手续费收取等

请求方式 GET
请求路径 /v1/ledger
权限: View, Trade
请求参数(需要排序)

参数名称	参数类型	是否必传	说明
asset	string	否	资产代码，如 BTC, ETH 等可按以下两种形式指定多个资产代码 1. /v1/ledger?asset=BTC,ETH 2. /v1/ledger?asset=BTC&asset=ETH 如果不指定 asset 参数, 则返回全部资产的账单记录
start_time	int64	否	限定返回账单记录的最早时间
end_time	int64	否	限定返回账单记录的最近时间
before	int64	否	账单记录id 限定返回账单记录的最大id值
after	int64	否	账单记录id 限定返回账单记录的最小id值
limit	int32	否	限定返回账单记录的最大条数默认值 100
type	string	否	账单类型 transfer划转，trade交易，fee手续费，rebate系统收取，funding资金费用

Data Source

创建订单

Request

let CryptoJS = require("crypto-js");
let request = require("request");

const endpoints = 'https://api-user.ktx.com/api'
const apikey = "9e03e8fda27b6e4fc6b29bb244747dcf64092996"; // your apikey
const secret = "b825a03636ca09c884ca11d71cfc4217a98cb8bf"; // your secret

const param = {
    symbol:'BTC_USDT',
    quantity:'0.0001',
    price:'90000',
    type:'limit',
    market:'spot',
}

let bodyStr = JSON.stringify(param);
const sign = CryptoJS.HmacSHA256(bodyStr, secret).toString();
const url = `${endpoints}/v1/order`;

request.post({
        url:url,
        body:param,
        json:true,
        headers: {
            'Content-Type': 'application/json',
            'api-key': apikey,
            'api-sign': sign,
            'api-expire-time':Date.now()+5000  // optional
        },
    },

    function optionalCallback(err, httpResponse, body) {
        if (err) {
            return console.error('upload failed:', err);
        }
        console.log(body) // 7.the result

    });

import hashlib
import hmac
import requests
import json
import time

END_POINT = 'https://api-user.ktx.com/api'
API_KEY = '9e03e8fda27b6e4fc6b29bb244747dcf64092996'
SECRET_KEY = 'b825a03636ca09c884ca11d71cfc4217a98cb8bf'
t = time.time()


def do_request():

    param = {
      'symbol':'BTC_USDT',
      'quantity':'0.0001',
      'price':'90000',
      'type':'limit',
      'market':'spot',
    }
    body_str = json.dumps(param)
    sign = hmac.new(SECRET_KEY.encode("utf-8"), body_str.encode("utf-8"), hashlib.sha256).hexdigest()
    path = '/v1/order'
    headers = {
        'Content-Type': 'application/json',
        'api-key': API_KEY,
        'api-sign': sign,
        'api-expire-time':str(round(t * 1000 +5000)) # optional
    }
    resp = requests.post(END_POINT + path, json=param, headers=headers)
    print(resp.text)


if __name__ == '__main__':
    do_request()

Response

{
  "orderId": "4611767382287843330", // 订单id
  "clientOrderId": "",  // 自定义id
  "createTime": "1733390630904", // 创建时间
  "product": "BTC_USDT", // 交易对代码
  "type": "limit", // 订单类型
  "side": "buy", // 交易方向
  "quantity": "0.01", // 委托数量
  "stf": "disabled",
  "price": "10300",  // 委托价格
  "visibleQty": "0.01",
  "timeInForce": "gtc",
  "cancelAfter": 0,
  "postOnly": false,
  "positionMerge": "none", // 仓位模式 none分仓 long合并多 short合并空
  "positionId": 0,  // 提交的仓位id
  "close": false,   // 是否为可平单
  "leverage": 0,    // 杠杠倍数
  "action": "unknown", // 仓位行为
  "status": "filled", // 订单状态
  "executedQty": "0.01", // 已成交数量
  "profit": "0",    // 收益
  "executedCost": "103", // 已成交价值
  "fillCount": 1, // 成交次数
  "fills": [  // 成交详情
    {
      "tradeId": 1,
      "time": "1733390650379",
      "price": "10300",
      "quantity": "0.01",
      "profit": "0",
      "taker": false,
      "fees": [
        {
          "amount": "0.103", // 资产数量
          "asset": "USDT", // 资产代码
          "value": "0.103" // 估值
        }
      ]
    }
  ],
  "fees": [  // 手续费
    {
      "amount": "0.103", // 资产数量
      "asset": "USDT", // 资产代码
      "value": "0.103" // 估值
    }
  ],
  "updateTime": "1733390650379" // 更新时间
}

提交委托

请求方式 POST
请求路径 /v1/order
权限: Trade
请求参数

参数名称	参数类型	是否必传	说明
symbol	string	是	交易对代码，如 BTC_USDT, ETH_USDT 等
type	string	是	委托类型，有效值 limit market
client_order_id	string	否	委托id，有效值为int64整数的字符串，建议使用提交委托时的Unix时间戳
quantity	decimal	是	委托量有正负
price	decimal	否	委托限价
market	string	是	必须 spot 现货，lpc U本位永续
positionMerge	string	否	合约必须 none分仓 long合并多 short合并空
marginMethod	string	否	合约必须 isolate 逐仓, cross 全仓
leverage	int	否	合约必须杠杠倍数
close	bool	否	合约必须 true 平仓单，false 开仓单
post_only	bool	否	...
time_in_force	string	否	委托时效性有效值 gtc, ioc gtc 表示未完全成交的委托将一直有效, 直到用户撤销该委托 ioc 表示撮合将立即撤销在下单时刻不能完全成交的委托, 任何成交都将被保留默认值 gtc
positionId	string	否	仓位id

委托对象最多包含该委托的20笔成交如果委托有多于20笔成交，那么该对象仅包含最后20笔，其他成交请通过 fills 接口获取

获取订单

Request

let CryptoJS = require("crypto-js");
let request = require("request");

const endpoints = 'https://api-user.ktx.com/api'
const apikey = "9e03e8fda27b6e4fc6b29bb244747dcf64092996"; // your apikey
const secret = "b825a03636ca09c884ca11d71cfc4217a98cb8bf"; // your secret


const queryStr = 'id=4611772879845982339';
const sign = CryptoJS.HmacSHA256(queryStr, secret).toString();
const url = `${endpoints}/v1/order?${queryStr}`;

request.get(url,{
        headers: {
            'Content-Type': 'application/json',
            'api-key': apikey,
            'api-sign': sign,
            'api-expire-time':Date.now()+5000  // optional
        },
    },

    function optionalCallback(err, httpResponse, body) {
        if (err) {
            return console.error('upload failed:', err);
        }
        console.log(body) // 7.the result

    });

import hashlib
import hmac
import requests

END_POINT = 'https://api-user.ktx.com/api'
API_KEY = '9e03e8fda27b6e4fc6b29bb244747dcf64092996'
SECRET_KEY = 'b825a03636ca09c884ca11d71cfc4217a98cb8bf'


def do_request():
    path = '/v1/order'
    query_str = 'id=14118828812271651'
    sign = hmac.new(SECRET_KEY.encode("utf-8"), query_str.encode("utf-8"), hashlib.sha256).hexdigest()

    headers = {
        'Content-Type': 'application/json',
        'api-key': API_KEY,
        'api-sign': sign,
        'api-expire-time':str(round(t * 1000 +5000)) # optional
    }
    resp = requests.get(END_POINT + path, query_str, headers=headers)
    print(resp.text)


if __name__ == '__main__':
    do_request()

Response

{
  "orderId": "4611767382287843330", // 订单id
  "clientOrderId": "",  // 自定义id
  "createTime": "1733390630904", // 创建时间
  "product": "BTC_USDT", // 交易对代码
  "type": "limit", // 订单类型
  "side": "buy", // 交易方向
  "quantity": "0.01", // 委托数量
  "stf": "disabled",
  "price": "10300",  // 委托价格
  "visibleQty": "0.01",
  "timeInForce": "gtc",
  "cancelAfter": 0,
  "postOnly": false,
  "positionMerge": "none", // 仓位模式 none分仓 long合并多 short合并空
  "positionId": 0,  // 提交的仓位id
  "close": false,   // 是否为可平单
  "leverage": 0,    // 杠杠倍数
  "action": "unknown", // 仓位行为
  "status": "filled", // 订单状态
  "executedQty": "0.01", // 已成交数量
  "profit": "0",    // 收益
  "executedCost": "103", // 已成交价值
  "fillCount": 1, // 成交次数
  "fills": [  // 成交详情
    {
      "tradeId": 1,
      "time": "1733390650379",
      "price": "10300",
      "quantity": "0.01",
      "profit": "0",
      "taker": false,
      "fees": [
        {
          "amount": "0.103", // 资产数量
          "asset": "USDT", // 资产代码
          "value": "0.103" // 估值
        }
      ]
    }
  ],
  "fees": [  // 手续费
    {
      "amount": "0.103", // 资产数量
      "asset": "USDT", // 资产代码
      "value": "0.103" // 估值
    }
  ],
  "updateTime": "1733390650379" // 更新时间
}

获取指定 id 的委托

请求方式 GET
请求路径 /v1/order
权限: View, Trade
请求参数

参数名称	参数类型	是否必传	说明
id	string	是	委托id 委托id可以是交易所分配的, 也可以是用户自定义的 (在提交委托时使用client_order_id参数). 当使用自定义id时, 需要在id前添加 “c:” 前缀. 例如: 提交委托时使用了自定义id “123”, 在获取委托时, 需使用 “c:123”.

获取订单

Request

let CryptoJS = require("crypto-js");
let request = require("request");

const endpoints = 'https://api-user.ktx.com/api'
const apikey = "9e03e8fda27b6e4fc6b29bb244747dcf64092996"; // your apikey
const secret = "b825a03636ca09c884ca11d71cfc4217a98cb8bf"; // your secret


const queryStr = 'limit=2&status=settled&market=spot&symbol=BTC_USDT';
const sign = CryptoJS.HmacSHA256(queryStr, secret).toString();
const url = `${endpoints}/v1/orders?${queryStr}`;

request.get(url,{
        headers: {
            'Content-Type': 'application/json',
            'api-key': apikey,
            'api-sign': sign,
            'api-expire-time':Date.now()+5000  // optional
        },
    },

    function optionalCallback(err, httpResponse, body) {
        if (err) {
            return console.error('upload failed:', err);
        }
        console.log(body) // 7.the result

    });

import hashlib
import hmac
import requests

END_POINT = 'https://api-user.ktx.com/api'
API_KEY = '9e03e8fda27b6e4fc6b29bb244747dcf64092996'
SECRET_KEY = 'b825a03636ca09c884ca11d71cfc4217a98cb8bf'


def do_request():
    path = '/v1/orders'
    query_str = 'limit=2&status=settled&market=spot&symbol=BTC_USDT'
    sign = hmac.new(SECRET_KEY.encode("utf-8"), query_str.encode("utf-8"), hashlib.sha256).hexdigest()

    headers = {
        'Content-Type': 'application/json',
        'api-key': API_KEY,
        'api-sign': sign,
        'api-expire-time':str(round(t * 1000 +5000)) # optional
    }
    resp = requests.get(END_POINT + path, query_str, headers=headers)
    print(resp.text)


if __name__ == '__main__':
    do_request()

Response

[
  {
    "orderId": "4611767382287843330", // 订单id
    "clientOrderId": "",  // 自定义id
    "createTime": "1733390630904", // 创建时间
    "product": "BTC_USDT", // 交易对代码
    "type": "limit", // 订单类型
    "side": "buy", // 交易方向
    "quantity": "0.01", // 委托数量
    "stf": "disabled",
    "price": "10300",  // 委托价格
    "visibleQty": "0.01",
    "timeInForce": "gtc",
    "cancelAfter": 0,
    "postOnly": false,
    "positionMerge": "none", // 仓位模式 none分仓 long合并多 short合并空
    "positionId": 0,  // 提交的仓位id
    "close": false,   // 是否为可平单
    "leverage": 0,    // 杠杠倍数
    "action": "unknown", // 仓位行为
    "status": "filled", // 订单状态
    "executedQty": "0.01", // 已成交数量
    "profit": "0",    // 收益
    "executedCost": "103", // 已成交价值
    "fillCount": 1, // 成交次数
    "fills": [  // 成交详情
      {
        "tradeId": 1,
        "time": "1733390650379",
        "price": "10300",
        "quantity": "0.01",
        "profit": "0",
        "taker": false,
        "fees": [
          {
            "amount": "0.103", // 资产数量
            "asset": "USDT", // 资产代码
            "value": "0.103" // 估值
          }
        ]
      }
    ],
    "fees": [  // 手续费
      {
        "amount": "0.103", // 资产数量
        "asset": "USDT", // 资产代码
        "value": "0.103" // 估值
      }
    ],
    "updateTime": "1733390650379" // 更新时间
  },
  ...
]

获取ApiKey对应账户中符合下列条件的委托

全部未结算委托
三个月内的已结算委托, 含已拒绝, 已撤销和已成交委托
全部已成交委托
全部已撤销的部分成交委托

请求方式 GET
请求路径 /v1/orders
权限: View, Trade
请求参数(需要排序)

参数名称	参数类型	是否必传	说明
status	string	否	有效值 unsettled, settled unsettled 表示获取未结算委托，返回结果按委托创建时间倒序排序 settled 表示获取已结算委托，返回结果按委托结算时间倒序排序默认值 unsettled
market	string	否	交易对市场，如 spot, lpc 等，spot为现货,lpc为U本位合约
symbol	string	否	交易对代码，如 BTC_USDT, ETH_USDT 等当 status=unsettled 时, 不指定 symbol 将返回全部交易对的未结算委托当 status=settled 时, 必须给定 symbol 参数
start_time	long	否	限定返回委托的最近创建时间
end_time	long	否	限定返回委托的最近创建时间
before	int64	否	委托更新 id 限定返回委托的最大更新id
after	int64	否	委托更新 id 限定返回委托的最小更新id
limit	long	否	指定最多返回多少个委托

该接口支持的参数组合和数据源
- status=unsettled + symbol
- status=settled + symbol + start_time
- status=settled + symbol + start_time + limit
- status=settled + symbol + end_time
- status=settled + symbol + end_time + limit
- status=settled + symbol + start_time + end_time
- status=settled + symbol + start_time + end_time + limit
- status=settled + symbol + before
- status=settled + symbol + before + limit
- status=settled + symbol + after
- status=settled + symbol + after + limit

返回的unsettled委托按创建时间由早及近排序返回的settled委托按结算时间由早及近排序

取消订单

Request

let CryptoJS = require("crypto-js");
let request = require("request");

const endpoints = 'https://api-user.ktx.com/api'
const apikey = "9e03e8fda27b6e4fc6b29bb244747dcf64092996"; // your apikey
const secret = "b825a03636ca09c884ca11d71cfc4217a98cb8bf"; // your secret

const param = {
    id:'14244173146202090'
}

let bodyStr = JSON.stringify(param);
const sign = CryptoJS.HmacSHA256(bodyStr, secret).toString();
const url = `${endpoints}/v1/order/delete`;

request.post({
        url:url,
        body:param,
        json:true,
        headers: {
            'Content-Type': 'application/json',
            'api-key': apikey,
            'api-sign': sign,
            'api-expire-time':Date.now()+5000 // optional
        },
    },

    function optionalCallback(err, httpResponse, body) {
        if (err) {
            return console.error('upload failed:', err);
        }
        console.log(body) // 7.the result

    });

import hashlib
import hmac
import requests
import json
import time

END_POINT = 'https://api-user.ktx.com/api'
API_KEY = '9e03e8fda27b6e4fc6b29bb244747dcf64092996'
SECRET_KEY = 'b825a03636ca09c884ca11d71cfc4217a98cb8bf'
t = time.time()

def do_request():

    param = {
        'id': '14245272657638034'
    }
    body_str = json.dumps(param)
    sign = hmac.new(SECRET_KEY.encode("utf-8"), body_str.encode("utf-8"), hashlib.sha256).hexdigest()
    path = '/v1/order/delete'
    headers = {
        'Content-Type': 'application/json',
        'api-key': API_KEY,
        'api-sign': sign,
        'api-expire-time':str(round(t * 1000 +5000)) #optional
    }
    resp = requests.post(END_POINT + path, json=param, headers=headers)
    print(resp.text)


if __name__ == '__main__':
    do_request()

Response

[n] // 取消数量

撤销指定 id 的委托

请求方式 DELETE
请求路径 /v1/order
权限: Trade
请求参数

参数名称	参数类型	是否必传	说明
id	string	是	委托id 委托id可以是交易所分配的，也可以是用户自定义的（在提交委托时使用client_order_id参数）。当使用自定义id时，需要在id前添加 “c:” 前缀。例如：提交委托时使用了自定义id “123”, 在撤销委托时，需使用 “c:123”。
market	string	是	交易对市场，如 spot, lpc 等，spot为现货,lpc为U本位合约

如果指定id的委托已结算，或者不存在指定id的委托，会收到-30001错误。

取消批量订单

Request

let CryptoJS = require("crypto-js");
let request = require("request");

const endpoints = 'https://api-user.ktx.com/api'
const apikey = "9e03e8fda27b6e4fc6b29bb244747dcf64092996"; // your apikey
const secret = "b825a03636ca09c884ca11d71cfc4217a98cb8bf"; // your secret

const param = {
    symbol:'BTC_USDT'
}

let bodyStr = JSON.stringify(param);
const sign = CryptoJS.HmacSHA256(bodyStr, secret).toString();
const url = `${endpoints}/v1/orders`;

request.delete({
        url:url,
        body:param,
        json:true,
        headers: {
            'Content-Type': 'application/json',
            'api-key': apikey,
            'api-sign': sign,
            'api-expire-time':Date.now()+5000 // optional
        },
    },

    function optionalCallback(err, httpResponse, body) {
        if (err) {
            return console.error('upload failed:', err);
        }
        console.log(body) // 7.the result

    });

import hashlib
import hmac
import requests
import json
import time

END_POINT = 'https://api-user.ktx.com/api'
API_KEY = '9e03e8fda27b6e4fc6b29bb244747dcf64092996'
SECRET_KEY = 'b825a03636ca09c884ca11d71cfc4217a98cb8bf'
t = time.time()

def do_request():

    param = {
        'symbol': 'BTC_USDT'
    }
    body_str = json.dumps(param)
    sign = hmac.new(SECRET_KEY.encode("utf-8"), body_str.encode("utf-8"), hashlib.sha256).hexdigest()
    path = '/v1/orders'
    headers = {
        'Content-Type': 'application/json',
        'api-key': API_KEY,
        'api-sign': sign,
        'api-expire-time':str(round(t * 1000 +5000)) # optional

    }
    resp = requests.delete(END_POINT + path, json=param, headers=headers)
    print(resp.text)


if __name__ == '__main__':
    do_request()

Response

[n] // 取消数量

撤销全部委托

请求方式 DELETE
请求路径 /v1/orders
权限: Trade
请求参数

参数名称	参数类型	是否必传	说明
market	string	是	交易对市场，如 spot, lpc 等，spot为现货,lpc为U本位合约
symbol	string	是	交易对代码如 BTC_USDT, ETH_USDT 等
side	string	否	buy 或者 sell

如果请求被正确执行，返回空数组，否则返回错误信息

获取成交明细

Request

let CryptoJS = require("crypto-js");
let request = require("request");

const endpoints = 'https://api-user.ktx.com/api'
const apikey = "9e03e8fda27b6e4fc6b29bb244747dcf64092996"; // your apikey
const secret = "b825a03636ca09c884ca11d71cfc4217a98cb8bf"; // your secret


const queryStr = 'limit=2&market=spot&symbol=BTC_USDT';
const sign = CryptoJS.HmacSHA256(queryStr, secret).toString();
const url = `${endpoints}/v1/fills?${queryStr}`;

request.get(url,{
        headers: {
            'Content-Type': 'application/json',
            'api-key': apikey,
            'api-sign': sign,
            'api-expire-time':Date.now()+5000 // optional

        },
    },

    function optionalCallback(err, httpResponse, body) {
        if (err) {
            return console.error('upload failed:', err);
        }
        console.log(body) // 7.the result

    });

import hashlib
import hmac
import requests

END_POINT = 'https://api-user.ktx.com/api'
API_KEY = '9e03e8fda27b6e4fc6b29bb244747dcf64092996'
SECRET_KEY = 'b825a03636ca09c884ca11d71cfc4217a98cb8bf'


def do_request():
    path = '/v1/fills'
    query_str = 'limit=2&market=spot&symbol=BTC_USDT'
    # POST or DELETE replace query_str with body_str
    sign = hmac.new(SECRET_KEY.encode("utf-8"), query_str.encode("utf-8"), hashlib.sha256).hexdigest()

    headers = {
        'Content-Type': 'application/json',
        'api-key': API_KEY,
        'api-sign': sign,
        'api-expire-time':str(round(t * 1000 +5000)) # optional
    }
    resp = requests.get(END_POINT + path, query_str, headers=headers)
    print(resp.text)


if __name__ == '__main__':
    do_request()

Response

[
  {
    "product":"BTC_USDT_SWAP", // 交易对代码
    "fees":[{"amount":"10","asset":"USDT"}],// 手续费
    "quantity":"0.01", // 成交数量
    "orderId":"4611772879845982371", // 订单id
    "price":"1000000", // 成交价格
    "time":"1733541360859", // 成交时间
    "taker":true, // 是否为吃单
    "profit":"-9060", // 收益
    "tradeId":26 
  },
  ...
]

获取成交记录

请求方式 GET
请求路径 /v1/fills
权限: View, Trade
请求参数(需要排序)

参数名称	参数类型	是否必传	说明
market	string	是	交易对市场，如 spot, lpc 等，spot为现货,lpc为U本位合约
order_id	string	否	交易所分配的委托id 限定仅返回指定委托的成交记录如果不指定该参数，请指定 symbol
symbol	string	否	交易对代码如 BTC_USDT, ETH_USDT 等限定仅返回指定交易对的成交记录如果不指定该参数，请指定 order_id
start_time	int64	否	限定返回成交记录的最早时间
end_time	int64	否	限定返回成交记录的最近时间
before	int64	否	成交记录 id 限定返回成交记录的最大id
after	int64	否	成交记录 id 限定返回成交记录的最小id
limit	int32	否	限定返回结果的最大条数默认值 100

该接口支持的参数组合和数据源
- symbol --> database
- symbol + limit --> database
- symbol + start_time --> database
- symbol + start_time + limit --> database
- symbol + end_time --> database
- symbol + end_time + limit --> database
- symbol + start_time + end_time --> database
- symbol + start_time + end_time + limit --> database
- symbol + before --> database
- symbol + before + limit --> database
- symbol + after --> database
- symbol + after + limit --> database
- order_id --> database
- order_id + limit --> database
- order_id + before --> database
- order_id + before + limit --> database

返回结果按成交记录id由小到大排序

User Data 推送

Overview

例子

const CryptoJS = require("crypto-js");
const WebSocket = require('ws');
const ktxws = 'wss://ktx-user.ktx.com';
const apikey = "9e2bd17ff73e8531c0f3c26f93e48bfa402a3b13"; // your apikey
const secret = "ca55beb9e45d4f30b3959b464402319b9e12bac7"; // your secret
const sign = CryptoJS.HmacSHA256("/user/verify", secret).toString();

let wsClass = function () {
};


wsClass.prototype._initWs = async function () {
  let that = this;
  console.log(ktxws);

  let ws = new WebSocket(ktxws);
  that.ws = ws;

  ws.on('open', function open() {
    console.log(new Date(), 'open')
    ws.send(JSON.stringify({
      "method": "LOGIN",
      "auth": {
        "api-key": apikey, "api-sign": sign,
      }
    }));
    setInterval(function () {
      ws.ping(Date.now())
    },30000)
  });

  ws.on('close', data => {
    console.log('close, ', data);
  });

  ws.on('error',  data => {
    console.log('error ',data);
  });

  ws.on('ping', data => {
    console.log('ping ', data.toString('utf8'));
  });

  ws.on('pong', data => {
    console.log('pong ', data.toString('utf8'));
  });

  ws.on('message', data => {
    console.log(data.toString()) // the data may be is error message,check the data's stream is order or account
  });
};

let instance = new wsClass();

instance._initWs().catch(err => {
  console.log(err);
});

import websocket
import hashlib
import hmac
import json

ws_url = 'wss://user-wss.ktx360.com'
API_KEY = '9e2bd17ff73e8531c0f3c26f93e48bfa402a3b13'
SECRET_KEY = 'ca55beb9e45d4f30b3959b464402319b9e12bac7'
SIGN = hmac.new(SECRET_KEY.encode("utf-8"), "/user/verify".encode('utf-8'), hashlib.sha256).hexdigest()

def on_message(ws, message):
    print(message)


def on_error(ws, error):
    print(error)


def on_close(ws):
    print("### closed ###")


def on_open(ws):
    ws.send(json.dumps({
        "method": "LOGIN",
        "auth": {
            "api-key": API_KEY,
            "api-sign": SIGN,
        }
    }))
    print("### opened ###")


def connect():
    # websocket.enableTrace(True)

    ws = websocket.WebSocketApp(ws_url,
                                on_message=on_message,
                                on_error=on_error,
                                on_close=on_close)
    ws.on_open = on_open
    ws.run_forever(ping_interval=30, ping_timeout=5)


if __name__ == "__main__":
    connect()

使用 Websocket 推送服务可以及时获取账户的余额及委托变动信息。

连接 Websocket 服务器

请使用以下 URL 连接 Websocket 服务器：

wss://user-wss.ktx360.com

在连接时，请附加以下HTTP请求头

api-key
api-sign
api-expire-time

具体方法请参考Authentication章节

数据流在成功建立连接后，客户端将收到ApiKey对应账户的余额变动信息及委托变动信息。格式如下:

{
  "stream": "account",
  "data": { Account }
}

{
  "stream": "order",
  "data": { Order }
}

{
  "stream": "order",
  "data": { Position }
}

Account

当账户余额发生变更时，会收到account事件

{
  "stream": "account",
  "data": {
      "asset":"USDT", // 资产代码
      "balance":"100000", // 余额
      "holds":"20016.9970000" // 冻结
  }
}

Position

当仓位信息发送变更时，会收到position事件 javascript { "stream": "position", "data": { "id":"1125899906842624003", // 仓位id "symbol":"BTC_USDT_SWAP", // 交易对代码 "quantity":"0", // 数量 "entryPrice":"0", // 开仓均价 "mergeMode":"none", // 仓位模式 "marginMethod":"isolate",//仓位模式 "leverage":"10.0", // 杠杠 "initMargin":"0.1", // 起始保证金率 "maintMargin":"0.005",// 维持保证金率 "posMargin":"0", // 持仓保证金 "orderMargin":"1009.8990000" // 委托保证金 } }

Order

当委托发生变更时，会收到order事件

{
  "stream": "order",
  "data":{
    "orderId": "4611767382287843330", // 订单id
      "clientOrderId": "",  // 自定义id
      "createTime": "1733390630904", // 创建时间
      "product": "BTC_USDT", // 交易对代码
      "type": "limit", // 订单类型
      "side": "buy", // 交易方向
      "quantity": "0.01", // 委托数量
      "stf": "disabled",
      "price": "10300",  // 委托价格
      "visibleQty": "0.01",
      "timeInForce": "gtc",
      "cancelAfter": 0,
      "postOnly": false,
      "positionMerge": "none", // 仓位模式 none分仓 long合并多 short合并空
      "positionId": 0,  // 提交的仓位id
      "close": false,   // 是否为可平单
      "leverage": 0,    // 杠杠倍数
      "action": "unknown", // 仓位行为
      "status": "filled", // 订单状态
      "executedQty": "0.01", // 已成交数量
      "profit": "0",    // 收益
      "executedCost": "103", // 已成交价值
      "fillCount": 1, // 成交次数
      "fills": [  // 成交详情
      {
        "tradeId": 1,
        "time": "1733390650379",
        "price": "10300",
        "quantity": "0.01",
        "profit": "0",
        "taker": false,
        "fees": [
          {
            "amount": "0.103", // 资产数量
            "asset": "USDT", // 资产代码
            "value": "0.103" // 估值
          }
        ]
      }
    ],
      "fees": [  // 手续费
      {
        "amount": "0.103", // 资产数量
        "asset": "USDT", // 资产代码
        "value": "0.103" // 估值
      }
    ],
      "updateTime": "1733390650379" // 更新时间
  }
}

Errors

错误码

Code	描述
-1000	无效请求
-1001	无效方法
-1002	丢失参数
-1003	无效参数
-10001	未知错误
-20001	未知事件
-20002	未知请求
-20003	不支持的事件
-20004	不支持的请求
-20005	过期请求
-20006	限制超出
-20007	使用次数超出
-20008	没有权限
-21001	丢失参数
-21002	空参数
-21003	无效的参数
-21004	丢失请求头
-21005	空的请求头
-21006	无效的请求头
-21007	格式化错误
-21008	无效的签名
-22001	无效的划转
-22002	无效的订单
-22003	产品不存在
-30001	不存在
-30002	重复
-30003	已经在使用
-30004	超出限制
-30005	金额不足