入门指引

欢迎使用OKCoinJapan开发者文档。此文档目前为V3 Beta版，会继续更新，请大家及时关注。

此文档为用户提供了一整套简单而又强大的开发工具，旨在帮助用户快速、高效地将OKCoinJapan交易功能整合到自己的应用当中。
OKCoinJapan接口是提供服务的基础，API分为账户、交易和行情三类。开发者在OKCoinJapan网站创建账号后，可以根据自身需求建立不同权限的API，并利用API进行自动交易或者提现。
账户和交易API需要身份验证，提供下单、撤单，查询订单和帐户信息等功能。行情API提供市场的行情数据，所有行情接口都是公开的。

使用流程

步骤：开发者如需使用API ，请先申请v3APIKey等信息 点击申请APIKey，然后根据此文档详情进行开发交易，使用过程中如有问题或者建议请及时反馈。 可参考SDK(点击跳转SDK详情页面)

接口调用方式说明

OKCoinJapan为用户提供两种调用接口的方式，开发者可根据自己的使用场景和偏好选择适合自己的方式来查询行情、进行交易或提现。

Rest API

REST，即Representational State Transfer的缩写，是目前最流行的一种互联网软件架构。它结构清晰、符合标准、易于理解、扩展方便，正得到越来越多网站的采用。其优点如下：

• 在RESTful架构中，每一个URL代表一种资源；
• 客户端和服务器之间，传递这种资源的某种表现层；
• 客户端通过四个HTTP指令，对服务器端资源进行操作，实现"表现层状态转化"。 建议开发者使用Rest API进行币币交易或者资产提现等操作。

HTTP/2支持
HTTP/2 是最新版本的HTTP 协议，通过多路复用等方式对HTTP/1.1 进行了改进，在一些场景下提高了性能：
1）目前全站支持通过HTTP/1.1 与HTTP/2 协议访问；
2）对于支持的客户端，HTTP/2 是自动生效的，不需要另外进行调整；
3）对于使用较旧浏览器或程序库的客户，会保持兼容性，使用HTTP/1.1；

WebSocket API

WebSocket是HTML5一种新的协议（Protocol）。它实现了客户端与服务器全双工通信，使得数据可以快速地双向传播。通过一次简单的握手就可以建立客户端和服务器连接，服务器根据业务规则可以主动推送信息给客户端。其优点如下：

• 客户端和服务器进行数据传输时，请求头信息比较小，大概2个字节;
• 客户端和服务器皆可以主动地发送数据给对方；
• 不需要多次创建TCP请求和销毁，节约宽带和服务器的资源。 强烈建议开发者使用WebSocket API获取市场行情和买卖深度等信息。

更新日志

2024-04-09

以下2024年4月已上线

• 现货交易新增"止盈止损"委托策略:
  • 币币API - 委托策略下单
  • 币币API - 委托策略撤单
  • 币币API - 获取委托单列表
  • WebSocket API - 用户委托策略频道

2024-04-01

以下2024年4月已上线

• 以下API逻辑优化:
  • Funding Account API - 提现
    • 默认将资金提现至最近一笔提现订单的银行卡，若此卡不可用，则提现到最新添加或修改的银行卡。
      
      

2024-02-15

以下2024年2月已上线

• 以下API追加了返回结果的订单记录状态:
  • Funding Account API - 查询提现记录
    • 提现状态
      5:撤销中
      
      

2023-11-22

以下2023年11月已上线

• 以下API更新了返回结果的订单记录状态:
  • Funding Account API - 查询提现记录
    • 变更前: 提现状态
      3:提现成功
      0:提现中
      -1:提现失败
      -2:不可提现
      -3:已撤销
      -5:已返现
    • 变更后: 提现状态
      1:待处理
      2:提现中
      4:提现成功
      6:已撤销
      7:不可提现
      8:已返还
      9:提现失败
  • Funding Account API - 查询充值记录
    • 变更前: 充值状态
      3:充值成功
      0:处理中
      -3:退款成功
    • 变更后: 充值状态
      1:受理中
      2:确认中
      4:充值成功
      8:已实施退款处理
  • Funding Account API - 查询所有币种的提币记录 & 查询单个币种提币记录
    • 变更前: 提币状态
      -6:审核失败
      -5:审核失败
      -4:已退款
      -3:撤销中
      -2:已撤销
      -1:提现失败
      0:等待提现
      1:提现中
      2:提现成功
      3:等待邮箱确认
      4:等待客服审核
      7:等待客服审核
      10:等待客服审核
      11:等待客服审核
      12:等待客服审核
    • 变更后: 提币状态
      1:等待提币
      2:提币中
      3:审核中
      4:提币成功
      5:撤销中
      6:已撤销
      7:提币失败
      8:已退款
  • Funding Account API - 获取所有币种充值记录 & 获取单个币种充值记录
    • 变更前: 充值状态
      0:等待确认
      1:充值确认
      2:充值成功
    • 变更后: 充值状态
      1:等待确认
      2:充值中
      3:审核中
      4:充值成功
      7:充值失败

2022-05-12

以下2022年5月已上线

• 以下API加入了币种链信息:
  • Funding Account API - 获取币种列表
  • Funding Account API - 提币
  • Funding Account API - 查询所有币种的提币记录
  • Funding Account API - 查询单个币种提币记录
  • Funding Account API - 获取充值地址
  • Funding Account API - 获取所有币种充值记录
  • Funding Account API - 获取单个币种充值记录
  • Funding Account API - 提币手续费

2021-07-28

以下2021年7月已上线

• 支持内部转账:
  • 资金账户API - 提币

2020-10-14

以下2020年10月已上线

• 新增如下接口：

  • 资金账户API - 提币
  • 资金账户API - 日元提现
  • 资金账户API - 日元提现记录
  • 资金账户API - 日元充值记录

• 新增高级限价委托单(只做Maker(Post Only), 全部成交或立即取消(Fill Or Kill), 立即成交并取消剩余(Immediate Or Cancel)):

  • 币币API - 下单
  • 币币API - 批量下单

API概述

市场概况和基础信息

交易

1）币种

币种是指能够转入转出的基本单位，如BTC,ETH,BCH等。

2）币对

币对是由交易货币和计价货币组成。以BTC/JPY 为例，BTC 为交易货币，JPY 为计价货币，币对主要在币币交易区使用。

订单、成交相关ID说明

1）order_id

订单编号，每个业务线的同一币对下的订单ID是唯一的。

2）client_oid

客户自定义编号，为下单时的非必填参数，格式是字母（区分大小写）+数字 或者 纯字母（区分大小写），1-32位字符，建议用户定义的client_oid不要重复，否则多个order_id对应同一个client_oid时，查询将返回最近一个order_id

3）trade_id

成交的唯一编号

4）ledger_id

账单流水的唯一编号

订单种类

1）limit

限价委托规定了用户愿意买的最高价格或愿意卖的最低价格。用户在设定限价后，市场会以达到对有利方向的价格优先成交。

2）market

市价委托类型订单仅需指定下单金额或下单数量，不需要指定价格，订单在进入撮合时，会直接与对手方进行成交，直至金额或数量低于最小成交金额或成交数量为止。市价委托同样受限价机制限制。

订单状态

1）失败：该状态订单由于余额不足等原因不能校验通过进入撮合队列；

2）等待成交：该状态订单已进入撮合队列当中；

3）部分成交：该状态订单在撮合队列当中，订单的部分数量已经被市场成交，等待剩余部分成交；

4）完全成交：该状态订单在撮合队列当中已与对手方完全成交；

5）下单中：该状态订单正在下单的过程中，因订单最终需挂在撮合队列中才真正下单成功，所以此状态为中间过渡态；

6）撤单中：该状态订单正在被撤销的过程中，因订单最终需在撮合队列中剔除才会被真正撤销，所以此状态为中间过渡态。

撮合引擎

本章节主要为撮合引擎的细节分以下四个方面：

• 成交价
• 订单生命周期
• 币币交易限价规则

成交价

OKCoinJapan撮合系统撮合订单的优先级按照价格优于时间的优先级来撮合，优先撮合价格更有优势的订单。当价格一致时按照下单时间顺序撮合，先下单的先撮合。

比如深度列表中目前有3笔挂单等待成交，分别为1: 9900JPY买1BTC，2: 10100JPY买2BTC，3: 9900PY买1.5BTC。他们是按时间顺序1-2-3进入撮合系统的，根据价格优先，系统优先撮合订单2，根据时间优先，1跟3优先撮合1。所以系统撮合顺序是2-1-3。

订单撮合时成交价将按maker挂单价格成交，而非taker吃单价格。

例如：A用户在10000JPY挂了1BTC的买单，然后B用户以8000JPY的价格下了1BTC的卖单，因为A用户的订单先进入撮合系统挂在深度列表上，所以以A的价格为准，最终这笔订单最终以10000JPY成交。

订单生命周期

订单进入撮合引擎后是"未成交"状态；

如果一个订单被撮合而全部成交，那么它会变成"已成交"状态；

一个订单被撮合可能出现部分成交，那么他的状态会变成"部分成交"状态，并且继续留在撮合队列中进行撮合；

一个留在撮合队伍中等待撮合的订单被撤销，那么他的状态会变成"已撤销"状态；

发起撤消到完成撤消的过程中有一个过程状态"撤单中"；

被撤消或者全部成交的订单将被从撮合队列中剔除。

币币交易限价规则

为了防止用户下错大单造成市场异常波动和个人资金损失，OKCoinJapan币币交易设置了FOK限价规则：如果用户在币币交易所下的市价单/限价单可以与当前买卖盘内订单直接成交，那么系统会判断成交深度对应的价格与同方向盘口价的偏差是否超出30%。如果超过，则此订单将被系统立即全数撤销，否则此订单正常进行撮合。

例如：某用户在XRP/BTC交易区下了100BTC的市价买单(此时卖一价为0.00012)，系统判断订单完成成交后最新成交价为0.0002。此时，(0.0002-0.00012)/0.00012=66.7%>30%，用户的这笔市价买单将被立即撤销，不会和买卖盘内订单进行撮合。

费用

本章节主要为费用的细节分以下两个方面:

• 交易费用
• 充/提币费用

交易费用

OKCoinJapan采用maker-taker收费规则，为鼓励挂单，maker挂单成交的手续费会比taker吃单成交的手续费低。 同时，为了鼓励成交，OKCoinJapan推出阶梯手续费政策，根据你前30天的累计交易量划分不同的手续费等级，成交量越高，手续费等级越高，手续费越低。 除了手续费优惠，OKCoinJapan还为提供流动性的专业用户提供了市商计划。参与市商计划后，只要您能够提供稳定的深度以及盘口点差，即可获得Maker手续费返还。 详情请查看(点击跳转至费率详情页面)

充/提币费用

OKCoinJapan不收取任何充币/提币费用，往数字货币地址提币的过程中产生的矿工手续费需要用户自己承担。

服务器

OKCoinJapan的数据库和服务器运行在东京。为了最大限度地减少API访问延迟，建议您使用与东京通讯通畅的服务器。

请求

本章节主要为请求的细节分以下三个方面：

• 介绍
• 错误
• 成功

介绍

Rest API提供账户管理、行情查询和交易功能。

Rest API终端URL https://www.okcoin.jp/

同时OKCoinJapan还提供了WebSocket流，订阅WebSocket可以获取行情数据的推送。

WebSocket API终端URL wss://connect.okcoin.jp:443/ws/v3

所有请求基于Https协议，请求头信息中contentType需要统一设置为:’application/json’

错误

除非特殊说明，错误请求都通过HTTP 4xx或者状态码进行返回，返回内容还将包含错误原因、参数信息。您的HTTP库应配置为非2xx请求提供消息主体，以便您可以从主体读取消息字段。

常见错误码

成功

HTTP状态码200表示成功响应，并可能包含内容。如果响应含有内容，则将显示在相应的返回内容里面。

分页

OKCoinJapan对返回数组的有些REST请求使用游标分页。游标分页允许在当前结果页面之前和之后获取结果，并且非常适合实时数据。端点如/ trades，/ fills，/ orders，默认返回最新100项。要检索更多结果，后续请求应根据先前返回的数据指定要分页的方向。

before和after游标可以通过响应头OK-BEFORE和OK-AFTER。在初始请求之后发出页面请求时，您的请求应使用这些游标值。

例 GET/api/spot/v3/orders?before=2&limit=30

游标之前和之后 将before光标引用在结果页中的第一项和after光标引用了一组结果的最后一个数据。

headers将包含一个OK-BEFORE标头，该标头将返回光标id，以便在当前页面的下一个页面请求中使用。之前的页面是一个较新的页面，而不是在按时间顺序排列之前发生的页面。 响应还将包含一个OK-AFTER标头，该标头将返回光标id，以便在此页面之后的页面的下一个请求中使用。之后的页面是较旧的页面，而不是按时间顺序排在此页面之后的页面。

举例

1、GET/api/spot/v3/orders/BTC-JPY?state=2（返回BTC-JPY的最近100条全部成交订单）

2、GET/api/spot/v3/orders/BTC-JPY?state=2&limit=20（返回BTC-JPY的最近20条全部成交订单）

3、GET/api/sopt/v3/orders/BTC-JPY?state=2&after=251266960551&limit=20（返回order_id=251266960551更旧的20条全部成交订单，不包括251266960551）

4、GET/api/spot/v3/orders/BTC-JPY?state=2&before=2512669605532&limit=20（返回order_id=2512669605532更新的20条全部成交订单，不包括2512669605532）

标准规范

本章节主要为标准规范的细节分以下三个方面：

• 时间戳
• 数字
• ID

时间戳

除非另外指定，API中的所有时间戳均以毫秒为单位返回，符合ISO 8601标准。请确保您可以解析ISO 8601格式。

例子

2014-11-06T10:34:47.123Z

数字

为了保持跨平台时精度的完整性，十进制数字作为字符串返回。建议您在发起请求时也将数字转换为字符串以避免截断和精度错误。

整数（如交易编号和顺序）不加引号。

ID

除非另有说明，大多数标识符是UUID。当提出一个需要UUID的请求时，以下两个形式（有和没有破折号）都被接受。

132fb6ae-456b-4654-b4e0-d681ac05cea1或者132fb6ae456b4654b4e0d681ac05cea1

接口类型

本章节主要为接口类型的细节分以下两个方面：

• 公共接口
• 私有接口

公共接口

公共接口可用于获取配置信息和行情数据。公共请求无需认证即可调用。

私有接口

私有接口可用于订单管理和账户管理。每个私有请求必须使用规范的验证形式进行签名。

私有接口需要使用您的APIKey进行验证。您可以在这里生成APIKey。

访问限制

本章节主要为访问限制的细节分以下两个方面：

• Rest API
• WebSocket

当访问超过频率限制时，将返回429状态：请求太频繁。

Rest API

如果传入有效的APIKey 用UserID限速；如果没有则拿公网IP限速。

限速规则：各个接口有单独的说明，如果没有,一般接口限速为 6次/秒。

WebSocket

WebSocket将每个命令类型限制为每秒50条命令。

验证

本章节主要为验证的细节分以下五个方面：

• 生成APIKey
• 发起请求
• 签名
• 时间戳
• 获取服务器时间

生成APIKey

在对任何请求进行签名之前，您必须通过OKCoinJapan网站创建一个APIKey。创建APIKey后，您将获得3个必须记住的信息：

• APIKey
• SecretKey
• Passphrase
  APIKey和Secret将由OKCoinJapan随机生成和提供，Passphrase将由您提供以确保API访问的安全性。OKCoinJapan将存储Passphrase加密后的哈希值进行验证，但如果您忘记Passphrase，则无法恢复，请您通过OKCoinJapan网站重新生成新的APIKey。

发起请求

所有私有接口，REST请求头都必须包含以下内容：

OK-ACCESS-KEY字符串类型的APIKey。

OK-ACCESS-SIGN使用Base64编码签名(请参阅签名)。

OK-ACCESS-TIMESTAMP发起请求的时间戳。

OK-ACCESS-PASSPHRASE您在创建API密钥时指定的Passphrase。

所有请求都应该含有application/json类型内容，并且是有效的JSON。

public enum ContentTypeEnum {

    APPLICATION_JSON("application/json"),
    APPLICATION_JSON_UTF8("application/json; charset=UTF-8"),
    // The server does not support types
    APPLICATION_FORM("application/x-www-form-urlencoded; charset=UTF-8"),;


    private String contentType;

    ContentTypeEnum(String contentType) {
        this.contentType = contentType;
    }

    public String contentType() {
        return contentType;
    }
}


public enum HttpHeadersEnum {

    OK_ACCESS_KEY("OK-ACCESS-KEY"),
    OK_ACCESS_SIGN("OK-ACCESS-SIGN"),
    OK_ACCESS_TIMESTAMP("OK-ACCESS-TIMESTAMP"),
    OK_ACCESS_PASSPHRASE("OK-ACCESS-PASSPHRASE"),

    OK_FROM("OK-FROM"),
    OK_TO("OK-TO"),
    OK_LIMIT("OK-LIMIT"),;

    private String header;

    HttpHeadersEnum(String header) {
        this.header = header;
    }

    public String header() {
        return header;
    }
}

import com.okcoin.commons.okcoin.open.api.config.APIConfiguration;
import com.okcoin.commons.okcoin.open.api.constant.APIConstants;
import com.okcoin.commons.okcoin.open.api.enums.ContentTypeEnum;
import com.okcoin.commons.okcoin.open.api.enums.HttpHeadersEnum;
import com.okcoin.commons.okcoin.open.api.exception.APIException;
import com.okcoin.commons.okcoin.open.api.utils.DateUtils;
import com.okcoin.commons.okcoin.open.api.utils.HmacSHA256Base64Utils;
import okhttp3.*;
import okio.Buffer;

public class APIHttpClient {

    private APIConfiguration config;
    private APICredentials credentials;

    public APIHttpClient(APIConfiguration config, APICredentials credentials) {
        this.config = config;
        this.credentials = credentials;
    }

    public OkHttpClient client() {
        OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder();
        clientBuilder.connectTimeout(this.config.getConnectTimeout(), TimeUnit.SECONDS);
        clientBuilder.readTimeout(this.config.getReadTimeout(), TimeUnit.SECONDS);
        clientBuilder.writeTimeout(this.config.getWriteTimeout(), TimeUnit.SECONDS);
        clientBuilder.retryOnConnectionFailure(this.config.isRetryOnConnectionFailure());
        clientBuilder.addInterceptor((Interceptor.Chain chain) -> {
            Request.Builder requestBuilder = chain.request().newBuilder();
            String timestamp = DateUtils.getUnixTime();
            requestBuilder.headers(headers(chain.request(), timestamp));
            Request request = requestBuilder.build();
            if (this.config.isPrint()) {
                printRequest(request, timestamp);
            }
            return chain.proceed(request);
        });
        return clientBuilder.build();
    }

    private Headers headers(Request request, String timestamp) {
        Headers.Builder builder = new Headers.Builder();
        builder.add(APIConstants.ACCEPT, ContentTypeEnum.APPLICATION_JSON.contentType());
        builder.add(APIConstants.CONTENT_TYPE, ContentTypeEnum.APPLICATION_JSON_UTF8.contentType());
        builder.add(APIConstants.COOKIE, getCookie());
        if (StringUtils.isNotEmpty(this.credentials.getSecretKey())) {
            builder.add(HttpHeadersEnum.OK_ACCESS_KEY.header(), this.credentials.getApiKey());
            builder.add(HttpHeadersEnum.OK_ACCESS_SIGN.header(), sign(request, timestamp));
            builder.add(HttpHeadersEnum.OK_ACCESS_TIMESTAMP.header(), timestamp);
            builder.add(HttpHeadersEnum.OK_ACCESS_PASSPHRASE.header(), this.credentials.getPassphrase());
        }
        return builder.build();
    }

    private String getCookie() {
        StringBuilder cookie = new StringBuilder();
        cookie.append(APIConstants.LOCALE).append(this.config.getI18n().i18n());
        return cookie.toString();
    }

    private String sign(Request request, String timestamp) {
        String sign;
        try {
            sign = HmacSHA256Base64Utils.sign(timestamp, method(request), requestPath(request),
                    queryString(request), body(request), this.credentials.getSecretKey());
        } catch (IOException e) {
            throw new APIException("Request get body io exception.", e);
        } catch (CloneNotSupportedException e) {
            throw new APIException("Hmac SHA256 Base64 Signature clone not supported exception.", e);
        } catch (InvalidKeyException e) {
            throw new APIException("Hmac SHA256 Base64 Signature invalid key exception.", e);
        }
        return sign;
    }

    private String url(Request request) {
        return request.url().toString();
    }

    private String method(Request request) {
        return request.method().toUpperCase();
    }

    private String requestPath(Request request) {
        String url = url(request);
        url = url.replace(this.config.getEndpoint(), APIConstants.EMPTY);
        String requestPath = url;
        if (requestPath.contains(APIConstants.QUESTION)) {
            requestPath = requestPath.substring(0, url.lastIndexOf(APIConstants.QUESTION));
        }
        if(this.config.getEndpoint().endsWith(APIConstants.SLASH)){
            requestPath = APIConstants.SLASH + requestPath;
        }
        return requestPath;
    }

    private String queryString(Request request) {
        String url = url(request);
        String queryString = APIConstants.EMPTY;
        if (url.contains(APIConstants.QUESTION)) {
            queryString = url.substring(url.lastIndexOf(APIConstants.QUESTION) + 1);
        }
        return queryString;
    }

    private String body(Request request) throws IOException {
        RequestBody requestBody = request.body();
        String body = APIConstants.EMPTY;
        if (requestBody != null) {
            Buffer buffer = new Buffer();
            requestBody.writeTo(buffer);
            body = buffer.readString(APIConstants.UTF_8);
        }
        return body;
    }
}



import okhttp3.Headers;
import okhttp3.OkHttpClient;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import retrofit2.Call;
import retrofit2.Response;
import retrofit2.Retrofit;

import java.io.IOException;
import java.util.List;
import java.util.Optional;

public class APIClient {

    /**
     * Synchronous send request
     */
    public <T> T executeSync(Call<T> call) {
        try {
            Response<T> response = call.execute();
            if (this.config.isPrint()) {
                printResponse(response);
            }
            int status = response.code();
            String message = new StringBuilder().append(response.code()).append(" / ").append(response.message()).toString();
            if (response.isSuccessful()) {
                return response.body();
            } else if (APIConstants.resultStatusArray.contains(status)) {
                HttpResult result = JSON.parseObject(new String(response.errorBody().bytes()), HttpResult.class);
                result.setStatusCode(status);
                throw new APIException(result.message());
            } else {
                throw new APIException(message);
            }
        } catch (IOException e) {
            throw new APIException("APIClient executeSync exception.", e);
        }
    }

}

import hmac
import Base64
import requests
import json

CONTENT_TYPE = 'Content-Type'
OK_ACCESS_KEY = 'OK-ACCESS-KEY'
OK_ACCESS_SIGN = 'OK-ACCESS-SIGN'
OK_ACCESS_TIMESTAMP = 'OK-ACCESS-TIMESTAMP'
OK_ACCESS_PASSPHRASE = 'OK-ACCESS-PASSPHRASE'
APPLICATION_JSON = 'application/json'


# signature
def signature(timestamp, method, request_path, body, secret_key):
    if str(body) == '{}' or str(body) == 'None':
        body = ''
    message = str(timestamp) + str.upper(method) + request_path + str(body)
    mac = hmac.new(bytes(secret_key, encoding='utf8'), bytes(message, encoding='utf-8'), digestmod='sha256')
    d = mac.digest()
    return Base64.b64encode(d)


# set request header
def get_header(api_key, sign, timestamp, passphrase):
    header = dict()
    header[CONTENT_TYPE] = APPLICATION_JSON
    header[OK_ACCESS_KEY] = api_key
    header[OK_ACCESS_SIGN] = sign
    header[OK_ACCESS_TIMESTAMP] = str(timestamp)
    header[OK_ACCESS_PASSPHRASE] = passphrase
    return header


def parse_params_to_str(params):
    url = '?'
    for key, value in params.items():
        url = url + str(key) + '=' + str(value) + '&'

    return url[0:-1]


# Example Request 
# set the request url
base_url = 'https://www.okcoin.jp'
request_path = '/api/account/v3/currencies'
# set request header
header = get_header('your_api_key', signature('timestamp', 'GET', request_path, 'your_secret_key'), 'timestamp', 'your_passphrase')
# do request
response = requests.get(base_url + request_path, headers=header)
# json
print(response.json())


########################################################
# take order
base_url = 'https://www.okcoin.jp'
request_path = '/api/spot/v3/orders'

# request params
params = {'type': 'market', 'side': 'buy', 'instrument_id': 'BTC-JPY', 'size': '0.01', 'client_oid': '', 'price': '4500000'}

# request path
request_path = request_path + parse_params_to_str(params)
url = base_url + request_path

# request header and body
header = get_header('your_api_key', signature('timestamp', 'POST', request_path, 'your_secret_key'), 'timestamp', 'your_passphrase')
body = json.dumps(params)

# do request
response = requests.post(url, data=body, headers=header)

#########################################################
# get order info
base_url = 'https://www.okcoin.jp'
request_path = '/api/spot/v3/orders'

params = {'status':'7', 'instrument_id': 'BTC-JPY'}

# request path
request_path = request_path + parse_params_to_str(params)
url = base_url + request_path

# request header and body
header = get_header('your_api_key', signature('timestamp', 'GET', request_path, 'your_secret_key'), 'timestamp', 'your_passphrase')

# do request
response = requests.get(url, headers=header)

package okcoin

import (
    "bytes"
    "errors"
    "fmt"
    "io/ioutil"
    "net/http"
    "strconv"
    "Strings"
    "time"
)

type Client struct {
    Config     Config
    HttpClient *http.Client
}

type ApiMessage struct {
    Message String `json:"message"`
}

/*
 Get a http client
*/
func NewClient(config Config) *Client {
    var client Client
    client.Config = config
    timeout := config.TimeoutSecond
    if timeout <= 0 {
        timeout = 30
    }
    client.HttpClient = &http.Client{
        Timeout: time.Duration(timeout) * time.Second,
    }
    return &client
}

/*
 Send a http request to remote server and get a response data
*/
func (client *Client) Request(method String, requestPath String,
    params, result interface{}) (response *http.Response, err error) {
    config := client.Config
    // uri
    endpoint := config.Endpoint
    if Strings.HasSuffix(config.Endpoint, "/") {
        endpoint = config.Endpoint[0:len(config.Endpoint)-1]
    }
    url := endpoint + requestPath

    // get json and bin styles request body
    var jsonBody String
    var binBody = bytes.NewReader(make([]byte, 0))
    if params != nil {
        jsonBody, binBody, err = ParseRequestParams(params)
        if err != nil {
            return response, err
        }
    }

    // get a http request
    request, err := http.NewRequest(method, url, binBody)
    if err != nil {
        return response, err
    }

    // Sign and set request headers
    timestamp := IsoTime()
    preHash := PreHashString(timestamp, method, requestPath, jsonBody)
    sign, err := HmacSha256Base64Signer(preHash, config.SecretKey)
    if err != nil {
        return response, err
    }
    Headers(request, config, timestamp, sign)

    if config.IsPrint {
        printRequest(config, request, jsonBody, preHash)
    }

    // send a request to remote server, and get a response
    response, err = client.HttpClient.Do(request)
    if err != nil {
        return response, err
    }
    defer response.Body.Close()

    // get a response results and parse
    status := response.StatusCode
    message := response.Status
    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        return response, err
    }

    if config.IsPrint {
        printResponse(status, message, body)
    }

    response.Header.Add(ResultJsonString, String(body))

    if status >= 200 && status < 300 {
        if body != nil && result != nil {
            err := JsonBytes2Struct(body, result)
            if err != nil {
                return response, err
            }
        }
        return response, nil
    } else if status == 400 || status == 401 || status == 500 {
        if body != nil {
            var apiMessage ApiMessage
            err := JsonBytes2Struct(body, &apiMessage)
            if err != nil {
                return response, err
            }
            message = strconv.Itoa(status) + " " + apiMessage.Message
        }
        return response, errors.New(message)
    } else {
        return response, errors.New(message)
    }
    return response, nil
}

type Config struct {
    // Rest API endpoint url. eg: https://www.okcoin.jp/
    Endpoint String
    // The user's APIKey provided by OKCoinJapan.
    ApiKey String
    // The user's secret key provided by OKCoinJapan. The secret key used to sign your request data.
    SecretKey String
    // The Passphrase will be provided by you to further secure your API access.
    Passphrase String
    // Http request timeout.
    TimeoutSecond int
    // Whether to print API information
    IsPrint bool
    // Internationalization @see file: constants.go
    I18n String
}

/*
 Set http request headers:
   Accept: application/json
   Content-Type: application/json; charset=UTF-8  (default)
   Cookie: locale=en_US        (English)
   OK-ACCESS-KEY: (Your setting)
   OK-ACCESS-SIGN: (Use your setting, auto sign and add)
   OK-ACCESS-TIMESTAMP: (Auto add)
   OK-ACCESS-PASSPHRASE: Your setting
*/
func Headers(request *http.Request, config Config, timestamp string, sign string) {
    request.Header.Add(ACCEPT, APPLICATION_JSON)
    request.Header.Add(CONTENT_TYPE, APPLICATION_JSON_UTF8)
    request.Header.Add(COOKIE, LOCALE+config.I18n)
    request.Header.Add(OK_ACCESS_KEY, config.ApiKey)
    request.Header.Add(OK_ACCESS_SIGN, sign)
    request.Header.Add(OK_ACCESS_TIMESTAMP, timestamp)
    request.Header.Add(OK_ACCESS_PASSPHRASE, config.Passphrase)
}

func BuildParams(requestPath string, params map[string]string) string {
    urlParams := url.Values{}
    for k := range params {
        urlParams.Add(k, params[k])
    }
    return requestPath + "?" + urlParams.Encode()
}

func (client *Client) GetSpotInstrumentCandles(instrument_id string, options *map[string]string) (*[]interface{}, error) {
    r := []interface{}{}

    uri := "/api/spot/v3/instruments/" + instrument_id + "/candles"
    fullOptions := NewParams()
    if options != nil && len(*options) > 0 {
        fullOptions["start"] = (*options)["start"]
        fullOptions["end"] = (*options)["end"]
        fullOptions["granularity"] = (*options)["granularity"]
        uri = BuildParams(uri, fullOptions)
    }

    if _, err := client.Request(GET, uri, nil, &r); err != nil {
        return nil, err
    }
    return &r, nil
}


func NewTestClient() *Client {
    // Set API's config
    var config Config
    config.Endpoint = "https://www.okcoin.jp/"
    config.ApiKey = ""
    config.SecretKey = ""
    config.Passphrase = ""
    config.TimeoutSecond = 45
    config.IsPrint = false
    config.I18n = "en_US"

    client := NewClient(config)
    return client
}



import "testing"

const (
    instrument_id = "BTC-JPY"
    currency  = "BTC"
)

func TestGetSpotInstrumentCandles(t *testing.T) {
    options := map[string]string{}
    options["start"] = ""
    options["end"] = ""
    options["granularity"] = "300"
    candles, err := NewTestClient().GetSpotInstrumentCandles("BTC-JPY", &options)
    if err != nil {
        t.Error(err)
    }
    FmtPrintln(GUnitTest+"Spot instruments candles: ", candles)
}

时间戳

OK-ACCESS-TIMESTAMP请求头必须是UTC时区Unix时间戳的十进制秒数格式或ISO8601标准的时间格式，精确到毫秒

时间戳和服务器时间相差30秒以上的请求将被系统视为过期并拒绝。如果您认为服务器和API服务器之间存在较大的时间偏差，那么我们建议您使用获取服务器时间的接口来查询API服务器时间。

获取服务时间

获取API服务器的时间。此接口为公共接口，不需要身份验证。

HTTP请求

GET/api/general/v3/time

{

"iso": "2015-01-07T23:47:25.201Z",

"epoch": 1420674445.201

}

资金账户API

资金账户与交易账户之间的资金划转，获取充值地址，提现等功能。

资金账户信息

获取资金账户所有资产列表，查询各币种的余额、冻结和可用等信息。

限速规则：6次/s

HTTP请求

GET/api/account/v3/wallet

请求示例

GET/api/account/v3/wallet

[
    {
        "available":"37.11827078",
        "balance":"37.11827078",
        "currency":"ETH",
        "hold":"0"
    },
    {
        "available":"0",
        "balance":"0",
        "currency":"BTC",
        "hold":"0"
    }
]

单一币种账户信息

获取资金账户单个币种的余额、冻结和可用等信息。

限速规则：6次/s

HTTP请求

GET/api/account/v3/wallet/<currency>

请求示例

GET/api/account/v3/wallet/XMR

请求参数

[{
    "balance":"300.00000000",
    "available":"300.00000000",
    "hold":"0.00000000"
}]

获取币种列表

获取平台所有币种列表。并非所有币种都可被用于交易。在ISO 4217标准中未被定义的币种代码可能使用的是自定义代码。

限速规则：6次/s

HTTP请求

GET/api/account/v3/currencies

请求示例

GET/api/account/v3/currencies

[
    {
        "can_deposit":"1",
        "can_withdraw":"1",
        "currency":"PLT",
        "chain":"Palette(pPLT)",
        "min_withdrawal":"0.1",
        "name":""
    },
    {
        "can_deposit":"1",
        "can_withdraw":"1",
        "currency":"PLT",
        "chain":"Ethereum(ePLT)",
        "min_withdrawal":"0.1",
        "name":""
    }
]

获取账户资产估值

按照btc或法币计价单位，获取账户总资产的估值。

限速规则：1次/30s

HTTP请求

GET/api/account/v3/asset-valuation

请求示例

GET/api/account/v3/asset-valuation?account_type=1&valuation_currency=btc

请求参数

{
    "account_type": "0",
    "balance": 0.00878181,
    "valuation_currency": "JPY",
    "timestamp": "2019-12-09T10:28:23.002Z"
}

资金划转

OKCoinJapan站内在资金账户、交易账户之间进行资金划转。

限速规则：1次/2s（每个币种）

HTTP请求

POST /api/account/v3/transfer

请求示例

POST /api/account/v3/transfer{"currency":"btc","amount":1.5,"from":"6","to":"1"}（btc从资金账户划转到币币杠杆btc-jpy账户）

请求参数

{
    "transfer_id": "754147",
    "currency": "LTC",
    "from": "6",
    "amount": "0.1",
    "to": "1",
    "result": true
}

账单流水查询

查询资金账户账单流水，可查询最近一个月的数据。

限速规则：20次/2s

HTTP请求

GET/api/account/v3/ledger

请求示例

GET/api/account/v3/ledger?type=2&currency=btc&after=9260348&limit=10

请求参数

[
    {
        "amount":"-0.00100941",
        "balance":"0",
        "currency":"BTC",
        "fee":"0",
        "ledger_id":"9260348",
        "timestamp":"2018-10-19T01:12:21.000Z",
        "type":"To spot account"
    },
    {
        "amount":"0.00051843",
        "balance":"0.00100941",
        "currency":"BTC",
        "fee":"0",
        "ledger_id":"8987285",
        "timestamp":"2018-10-12T11:01:14.000Z",
        "type":"Get from activity"
    }
]

提现

日元提现API接口,默认将资金提现至最近一笔提现订单的银行卡，若此卡不可用，则提现到最新添加或修改的银行卡。

限速规则：1次/120s

HTTP请求

POST /api/account/v3/jpywithdrawal

请求示例

POST /api/account/v3/jpywithdrawal{"amount":10000,"trade_pwd":"123456"}

请求参数

{
    "amount":"10000",
    "withdraw_id":74629,
    "result":true
}

查询提现记录

查询日元的提现记录。

限速规则：6次/s

HTTP请求

GET/api/account/v3/jpyWithdrawal/history

请求示例

GET/api/account/v3/jpyWithdrawal/history

[
    {
        "amount":"10000",
        "fee":"400",
        "status":"1",
        "timestamp":"2018-09-30T02:49:29.001Z"
    },
    {
        "amount":"19800",
        "fee":"400",
        "status":"4",
        "timestamp":"2018-09-28T01:09:19.022Z"
    }
]

查询充值记录

查询日元的充值记录。

限速规则：6次/s

HTTP请求

GET/api/account/v3/jpyDeposit/history

请求示例

GET/api/account/v3/jpyDeposit/history

[
    {
        "amount":"10000",
        "status":"1",
        "timestamp":"2019-11-30T02:39:29.012Z"
    },
    {
        "amount":"7800",
        "status":"4",
        "timestamp":"2019-10-21T02:04:49.122Z"
    }
]

提币

限速规则：1次/10s

HTTP请求

POST /api/account/v3/withdrawal

请求示例

POST /api/account/v3/withdrawal{"amount":1,"fee":0.0005,"trade_pwd":"123456","currency":"BTC","to_address":"17DKe3kkkkiiiiTvAKKi2vMPbm1Bz3CMKw","usage_agreement":"1","reason":"2"}

请求参数

Notes

当目的/理由选择 【进口付款和中介贸易付款的结算】或【其他】时，由于需要确认更多详细的细节，可能需要更长的时间来完成提币。

{
    "amount":"0.1",
    "withdraw_id":67485,
    "currency":"BTC",
    "chain":"BTC",
    "result":true
}

查询所有币种的提币记录

查询最近所有币种的提币记录，为最近100条记录。

限速规则：6次/s

HTTP请求

GET/api/account/v3/withdrawal/history

请求示例

GET/api/account/v3/withdrawal/history

[
    {
        "withdraw_id":"1",
        "amount":"0.094",
        "fee":"0.01000000eth",
        "txid":"0x62477bac6509a04512819bb1455e923a60dea5966c7caeaa0b24eb8fb0432b85",
        "currency":"ETH",
        "chain":"ETH",
        "from":"13426335357",
        "to":"0xA41446125D0B5b6785f6898c9D67874D763A1519",
        "timestamp":"2018-04-22T23:09:45.000Z",
        "status":"2"
    },
    {
        "withdraw_id":"2",
        "amount":"0.01",
        "fee":"0.00000000btc",
        "txid":"",
        "currency":"BTC",
        "chain":"BTC",
        "from":"13426335357",
        "to":"13426335357",
        "timestamp":"2018-05-17T02:43:08.000Z",
        "status":"4"
    }
]

查询单个币种提币记录

查询单个币种的提币记录。

限速规则：6次/s

HTTP请求

GET/api/account/v3/withdrawal/history/<currency>

请求示例

GET/api/account/v3/withdrawal/history/btc

请求参数

[
    {
        "withdraw_id":"1",
        "amount":"0.01105486",
        "fee":"0.00000000btc",
        "currency":"BTC",
        "chain":"BTC",
        "txid": "66602e279569ba319a929f5bda731d228962bc67cd89dfa0d432d82722681d66",
        "from":"13426335357",
        "to":"13426335357",
        "timestamp":"2018-09-30T02:49:29.000Z",
        "status": "2"
    },
    {
        "withdraw_id":"2",
        "amount":"0.01144408",
        "fee":"0.00000000btc",
        "currency":"BTC",
        "chain":"BTC",
        "txid": "66602e279569ba319a929f5bda731d228962456475467d89dfa0d432d82722681d66",
        "from":"13426335357",
        "to":"13426335357",
        "timestamp":"2018-09-18T00:44:56.000Z",
        "status": "2"
    }
]

获取充值地址

获取各个币种的充值地址，包括曾使用过的老地址。

限速规则：20次/2s

HTTP请求

GET/api/account/v3/deposit/address

请求示例

GET/api/account/v3/deposit/address?currency=btc

请求参数

[
    {
        "address": "2Mti44L7thuxyzYiGzZyCcm9R7d7jgGwzZK",
        "chain": "BTC",
    }
]

获取所有币种充值记录

获取所有币种的充值记录，最多返回最近100条记录。

限速规则：6次/s

HTTP请求

GET/api/account/v3/deposit/history

请求示例

GET/api/account/v3/deposit/history

[
    {
        "amount":"0.01044408",
        "txid":"1915737_3_0_0_WALLET",
        "currency":"BTC",
        "chain":"BTC",
        "deposit_id":"1",
        "to":"",
        "timestamp":"2018-09-30T02:45:50.000Z",
        "status":"1"
    },
    {
        "amount":"491.6784211",
        "txid":"1744594_3_184_0_WALLET",
        "currency":"BTC",
        "chain":"BTC",
        "deposit_id":"2",
        "to":"",
        "timestamp":"2018-08-21T08:03:10.000Z",
        "status":"2"
    },
    {
        "amount":"223.18782496",
        "txid":"6d892c669225b1092c780bf0da0c6f912fc7dc8f6b8cc53b003288624c",
        "currency":"ETH",
        "chain":"ETH",
        "deposit_id":"3",
        "to":"39kK4XvgEuM7rX9frgyHoZkWqx4iKu1spD",
        "timestamp":"2018-08-17T09:18:40.000Z",
        "status":"4"
    }
]

获取单个币种充值记录

获取单个币种的充值记录，最多返回最近100条记录。

限速规则：6次/s

HTTP

GET/api/account/v3/deposit/history/<currency>

请求示例

GET/api/account/v3/deposit/history/btc

请求参数

[
    {
        "amount":"0.0835",
        "currency":"BTC",
        "chain":"BTC",
        "deposit_id":"1",
        "txid":"6d892c669225b1092c780bf0da0c6f912fc3e8f997dc8f6b8cc53b003288624c",
        "to":"39kK4XvgEuM7rX9frgyHoZkWqx4iKu1spD",
        "timestamp":"2018-06-09T07:57:09.000Z",
        "status":"2"
    },
    {
        "amount":"0.01",
        "currency":"BTC",
        "chain":"BTC",
        "deposit_id":"2",
        "txid":"590426_1_0_WALLET",
        "to":"",
        "timestamp":"2018-05-30T01:33:40.000Z",
        "status":"2"
    }
]

提币手续费

查询提现到数字货币地址时，建议网络手续费信息。手续费越高，网络确认越快。

限速规则：6次/s

HTTP请求

GET/api/account/v3/withdrawal/fee

请求示例

GET/api/account/v3/withdrawal/fee?currency=btc

请求参数

[
    {
        "currency":"BTC",
        "chain":"BTC",
        "max_fee":"0.02",
        "min_fee":"0.0005"
    },
    {
        "currency":"LTC",
        "chain":"LTC",
        "max_fee":"0.2",
        "min_fee":"0.001"
    },
    {
        "currency":"ETH",
        "chain":"ETH",
        "max_fee":"0.2",
        "min_fee":"0.01"
    }
]

错误码

错误码示例

币币API

币币交易的行情信息，账户信息，订单操作，订单查询，账单明细查询。

说明：因为要和老版本做兼融，实际有些接口返回参数会有多余，请以文档中返回参数说明为准。

例如币币账户信息接口返回frozen，hold和holds参数值相同，以hold为准；

币币账户信息

获取币币账户资产列表(仅展示拥有资金的币对)，查询各币种的余额、冻结和可用等信息。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/accounts

签名请求示例

GET/api/spot/v3/accounts

[
    {
        "hold":"0",
        "currency":"BTC",
        "balance":"0.0049925",
        "available":"0.0049925"
    },
    {
        "hold":"0",
        "currency":"JPY",
        "balance":"226.74061435",
        "available":"226.74061435"
    },
    {
        "hold":"0",
        "currency":"ETH",
        "balance":"0.4925",
        "available":"0.4925"
    }
]

单一币种账户信息

获取币币账户单个币种的余额、冻结和可用等信息。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/accounts/<currency>

签名请求示例

GET/api/spot/v3/accounts/btc

请求参数

{
    "hold":"0",
    "currency":"BTC",
    "balance":"0.0049925",
    "available":"0.0049925"
}

账单流水查询

列出账户资产流水。账户资产流水是指导致账户余额增加或减少的行为。流水会分页，并且按时间倒序排序和存储，最新的排在最前面。请参阅分页部分以获取第一页之后的其他记录。 本接口能查询最近3个月的数据。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/accounts/<currency>/ledger

签名请求示例

GET/api/spot/v3/accounts/btc/ledger?limit=3&after=2500723297813504

请求参数

[
    {
        "timestamp":"2019-03-18T07:26:50.000Z",
        "ledger_id":"3995466151",
        "created_at":"2019-03-18T07:26:50.000Z",
        "currency":"BTC",
        "amount":"0.0009985",
        "balance":"0.0049925",
        "type":"trade",
        "details":{
            "instrument_id":"BTC-JPY",
            "order_id":"2500723297813504",
            "product_id":"BTC-JPY"
        }
    },
    {
        "timestamp":"2019-03-18T07:26:50.000Z",
        "ledger_id":"3995466150",
        "created_at":"2019-03-18T07:26:50.000Z",
        "currency":"BTC",
        "amount":"0.0009985",
        "balance":"0.003994",
        "type":"trade",
        "details":{
            "instrument_id":"BTC-JPY",
            "order_id":"2500723297223680",
            "product_id":"BTC-JPY"
        }
    },
    {
        "timestamp":"2019-03-18T07:08:25.000Z",
        "ledger_id":"3995334780",
        "created_at":"2019-03-18T07:08:25.000Z",
        "currency":"BTC",
        "amount":"0.0009985",
        "balance":"0.0029955",
        "type":"trade",
        "details":{
            "instrument_id":"BTC-JPY",
            "order_id":"2500650881647616",
            "product_id":"BTC-JPY"
        }
    }
]

下单

币币交易提供限价单和市价单和高级限价单下单模式。只有当您的账户有足够的资金才能下单。

一旦下单，您的账户资金将在订单生命周期内被冻结。被冻结的资金以及数量取决于订单指定的类型和参数。

限速规则：100次/2s （不同币对之间限速不累计）

HTTP请求

POST /api/spot/v3/orders

签名请求示例

POST /api/spot/v3/orders{"type": "limit", "side": "buy", "instrument_id": "BTC-JPY", "size":"0.001", "client_oid": "oktspot79", "price": "4638.51", "notional": "", "order_type": "3"}

请求参数

限价单特殊参数

市价单特殊参数

返回参数

{
    "client_oid":"oktspot79",
    "error_message": "",
    "error_code": "0",
    "order_id":"2510789768709120",
    "result":true
}

批量下单

下指定币对的多个订单（每次只能下最多4个币对且每个币对可批量下10个单）

限速规则：50次/2s （不同币对之间限速累计）

HTTP请求

POST /api/spot/v3/batch_orders

签名请求示例

POST /api/spot/v3/batch_orders[{"client_oid":"ww20180728","instrument_id":"btc-jpy","side":"sell","type":"limit","size":"0.001","price":"100010","order_type ":"0"},{"client_oid":"w20180728","instrument_id":"btc-jpy","side":"sell","type":"limit","size":"0.001","price":"100020","order_type ":"0"}]

请求参数

限价单特殊参数

市价单特殊参数

{
    "btc_jpy":[
        {
            "client_oid":"oktspot80",
            "error_code":"0",
            "error_message":"",
            "order_id":"2510832677159936",
            "result":true
        },
        {
            "client_oid":"oktspot81",
            "error_code":"0",
            "error_message":"",
            "order_id":"2510832677225472",
            "result":true
        },
        {
            "client_oid":"oktspot82",
            "error_code":"0",
            "error_message":"",
            "order_id":"2510832677225473",
            "result":true
        }
    ]
}

撤销指定订单

撤销之前下的未完成订单。

限速规则：100次/2s （不同币对之间限速不累计）

HTTP请求

POST /api/spot/v3/cancel_orders/<order_id> or <client_oid>

签名请求示例

2018-10-12T07:34:30.223ZPOST/api/spot/v3/cancel_orders/a123{"instrument_id":"btc-jpy"}

请求参数

{
     "client_oid": "order123",
     "error_message": "",
     "error_code": "0",
     "order_id": "4407638476788736", 
     "result": true

}

批量撤销订单

撤销指定的某一种或多种币对的未完成订单（每次只能下最多4个币对且每个币对可批量下10个单）。

限速规则：100次/2s （不同币对之间限速累计）

HTTP请求

POST /api/spot/v3/cancel_batch_orders

签名请求示例

2018-10-12T07:30:49.664ZPOST /api/spot/v3/cancel_batch_orders[{"instrument_id":"btc-jpy","client_oids":["a123","a1234"]},{"instrument_id":"eth-jpy","client_oids":["a12345","a123456"]}]

请求参数

{
    "btc-jpy":[
    {
        "result":true,
        "client_oid":"a123",
        "error_message": "",
        "error_code": "0",
        "order_id": "2510832677225473"
     },
   {
        "result":true,
        "client_oid":"a1234",
        "error_message": "",
        "error_code": "0",
        "order_id": "2510832677225474"
     }
],
"eth-jpy":[
    {
       "result":true,
        "client_oid":"a12345",
        "error_message": "",
        "error_code": "0",
        "order_id": "2510832677225475"
     },
   {
       "result":true,
        "client_oid":"a123456",
        "error_message": "",
        "error_code": "0",
        "order_id": "2510832677225476"
     }
]
}

获取订单列表

列出您当前的订单信息（本接口能查询最近3个月订单信息）。这个请求支持分页，并且按委托时间倒序排序和存储，最新的排在最前面。

限速规则：10次/2s

HTTP请求

GET/api/spot/v3/orders

签名请求示例

2019-03-18T07:49:43.306ZGET/api/spot/v3/orders?instrument_id=BTC-JPY&state=-2&after=2500723297223680

请求参数

[
     {
            "client_oid":"oktspot76",
            "created_at":"2019-03-18T07:26:49.000Z",
            "filled_notional":"3.9734",
            "filled_size":"0.001",
            "funds":"",
            "instrument_id":"BTC-JPY",
            "notional":"",
            "order_id":"2500723297813504",
            "order_type":"0",
            "price":"4013",
            "price_avg": "4013",
            "product_id":"BTC-JPY",
            "side":"buy",
            "size":"0.001",
            "status":"filled",
            "state":"-2",
            "timestamp":"2019-03-18T07:26:49.000Z",
            "type":"limit"
     }

]

获取所有未成交订单

列出您当前所有的订单信息。这个请求支持分页，并且按时间倒序排序和存储，最新的排在最前面。请参阅分页部分以获取第一页之后的其他纪录。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/orders_pending

签名请求示例

2018-09-12T07:51:51.138ZGET/api/spot/v3/orders_pending?limit=2&instrument_id=BTC-JPY&after=2500723297223680

请求参数

[
        {
            "client_oid":"oktspot86",
            "created_at":"2019-03-20T03:28:14.000Z",
            "filled_notional":"0",
            "filled_size":"0",
            "funds":"",
            "instrument_id":"BTC-JPY",
            "notional":"",
            "order_id":"2511109744100352",
            "order_type":"0",
            "price":"3594.7",
            "price_avg":"",
            "product_id":"BTC-JPY",
            "side":"buy",
            "size":"0.001",
            "status":"open",
            "state":"0",
            "timestamp":"2019-03-20T03:28:14.000Z",
            "type":"limit"
        }
]

获取订单信息

通过订单ID获取单个订单信息。可以获取近3个月订单信息。已撤销的未成交单只保留2个小时。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/orders/<order_id>

或

GET/api/spot/v3/orders/<client_oid>

签名请求示例

2018-09-12T07:54:01.582ZGET/api/spot/v3/orders/23356?instrument_id=BTC-JPY

或

2018-09-12T07:54:01.582ZGET/api/spot/v3/orders/2e3356?instrument_id=BTC-JPY

请求参数

{
    "client_oid":"oktspot70",
    "created_at":"2019-03-15T02:52:56.000Z",
    "filled_notional":"3.8886",
    "filled_size":"0.001",
    "funds":"",
    "instrument_id":"BTC-JPY",
    "notional":"",
    "order_id":"2482659399697408",
    "order_type":"0",
    "price":"3927.3",
    "price_avg":"3927.3",
    "product_id":"BTC-JPY",
    "side":"buy",
    "size":"0.001",
    "status":"filled",
    "state":"2",
    "timestamp":"2019-03-15T02:52:56.000Z",
    "type":"limit"
}

获取成交明细

获取最近的成交明细表。这个请求支持分页，并且按成交时间倒序排序和存储，最新的排在最前面。请参阅分页部分以获取第一页之后的其他记录。 本接口能查询最近3月的数据。

限速规则：10次/2s

HTTP请求

GET/api/spot/v3/fills

签名请求示例

2018-09-12T07:56:11.922ZGET/api/spot/v3/fills?order_id=23212&instrument_id=btc-jpy&limit=2&after=2&before=4

请求参数

[
    {
        "created_at": "2019-11-25T07:45:05.000Z",
        "trade_id": "67",
        "currency": "JPY",
        "exec_type": "M",
        "fee": "-0.01915417",
        "instrument_id": "BCH-JPY",
        "ledger_id": "8161858573",
        "liquidity": "M",
        "order_id": "3927696997697536",
        "price": "1.7793",
        "product_id": "BCH-JPY",
        "side": "buy",
        "size": "19.1541645",
        "timestamp": "2019-11-25T07:45:05.000Z"
    },
    {
        "created_at": "2019-11-25T07:45:05.000Z",
        "trade_id": "68",
        "currency": "BCH",
        "exec_type": "M",
        "fee": "0",
        "instrument_id": "BCH-JPY",
        "ledger_id": "8161858572",
        "liquidity": "M",
        "order_id": "3927696997697536",
        "price": "1.7793",
        "product_id": "BCH-JPY",
        "side": "sell",
        "size": "10.765",
        "timestamp": "2019-11-25T07:45:05.000Z"
    }
]

获取当前账户交易手续费费率

获取您当前账户交易等级对应的手续费费率。

限速规则：1次/10s

HTTP请求

GET/api/spot/v3/trade_fee

签名请求示例

GET/api/spot/v3/trade_fee

{
    "maker": "0.001",
    "taker": "0.0015",
    "timestamp": "2019-12-05T09:06:20.260Z"
}

委托策略下单

委托策略下单

提供止盈止损策略

限速规则：40次/2s

HTTP请求

POST /api/spot/v3/order_algo

请求示例

POST /api/spot/v3/order_algo {"instrument_id":"ETH-JPY","mode":"1","order_type":"5","size":"0.1","side":"sell","tp_trigger_price":"487600","tp_price":"487601","tp_trigger_type":"1","sl_trigger_type":"1","sl_trigger_price":"487300","sl_price":"487299"}

请求参数（通用）

止盈止损参数

{
    "algo_id": 7988089778254848,
    "result": true,
    "error_message": "",
    "error_code": "0",
    "instrument_id": "ETH-JPY",
    "order_type": "5"
}

委托策略撤单

委托策略撤单

根据指定的algo_id撤销某个币的未完成订单，每次最多可撤10个。

限速规则：20 次/2s

HTTP请求

POST /api/spot/v3/cancel_batch_algos

请求示例

单个撤单：POST /api/spot/v3/cancel_batch_algos{"instrument_id": "BTC-JPY","order_type":"5","algo_ids": ["1600593327162368"]}

批量撤单：POST /api/spot/v3/cancel_batch_algos{"instrument_id": "BTC-JPY","order_type":"5","algo_ids": ["1600593327162368","1600593327162369"]}

请求参数

{
    "result": true,
    "error_message": "",
    "error_code": "0",
    "algo_ids": [
        "7988089778254848"
    ],
    "instrument_id": "ETH-JPY",
    "order_type": "5"
}

获取委托单列表

获取委托单列表

列出您当前所有的委托订单信息。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/algo

请求示例

GET/api/spot/v3/algo?instrument_id=BTC-JPY&order_type=5

请求参数

{
  "ETH-JPY": [
    {
      "sl_trigger_type": "1",
      "algo_id": "7988108725761024",
      "side": "sell",
      "rejected_at": "2021-11-11T10:03:52.431Z",
      "tp_trigger_price": "487600.0000000000000000",
      "sl_trigger_price": "4.0000000000000000",
      "sl_price": "3.0000000000000000",
      "instrument_id": "ETH-JPY",
      "mode": "1",
      "size": "0.1000000000000000",
      "tp_price": "487601.0000000000000000",
      "order_id": "0",
      "order_type": 5,
      "tp_trigger_type": "1",
      "timestamp": "2021-11-11T10:01:06.072Z",
      "status": "1"
    },
    {
      "sl_trigger_type": "1",
      "algo_id": "7988089778254848",
      "side": "sell",
      "rejected_at": "2021-11-11T10:03:52.431Z",
      "tp_trigger_price": "487600.0000000000000000",
      "sl_trigger_price": "4.0000000000000000",
      "sl_price": "3.0000000000000000",
      "instrument_id": "ETH-JPY",
      "mode": "1",
      "size": "0.1000000000000000",
      "tp_price": "487601.0000000000000000",
      "order_id": "0",
      "order_type": 5,
      "tp_trigger_type": "1",
      "timestamp": "2021-11-11T09:56:17.600Z",
      "status": "3"
    },
    {
      "sl_trigger_type": "1",
      "algo_id": "7980933024031744",
      "side": "sell",
      "rejected_at": "2021-11-11T10:03:52.431Z",
      "tp_trigger_price": "488888.0000000000000000",
      "sl_trigger_price": "487569.0000000000000000",
      "sl_price": "487568.0000000000000000",
      "instrument_id": "ETH-JPY",
      "mode": "1",
      "size": "10.0000000000000000",
      "tp_price": "488888.0000000000000000",
      "order_id": "7980933025277952",
      "order_type": 5,
      "tp_trigger_type": "1",
      "timestamp": "2021-11-10T03:36:13.550Z",
      "status": "2"
    }
  ]
}

公共-获取币对信息

获取交易币对的列表，查询各币对的交易限制和价格步长等信息。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/instruments

请求示例

GET/api/spot/v3/instruments`

[
    {
        "base_currency":"BTC",
        "instrument_id":"BTC-JPY",
        "min_size":"0.001",
        "quote_currency":"JPY",
        "size_increment":"0.00000001",
        "tick_size":"0.1"
    },
    {
        "base_currency":"ETH",
        "instrument_id":"ETH-JPY",
        "min_size":"0.001",
        "quote_currency":"JPY",
        "size_increment":"0.000001",
        "tick_size":"0.01"
    }
]

公共-获取深度数据

获取币对的深度列表。这个请求不支持分页，一个请求返回整个深度列表。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/instruments/<instrument_id>/book

请求示例

GET/api/spot/v3/instruments/BTC-JPY/book?size=5&depth=0.2

请求参数

返回参数

{
    "asks":[
        [
            "3993.2",
            "0.41600068",
            "1"
        ],
        [
            "3993.4",
            "1.24807818",
            "3"
        ]
    ],
    "bids":[
        [
            "3993",
            "0.15149658",
            "2"
        ],
        [
            "3992.8",
            "1.19046818",
            "1"
        ]
    ],
    "timestamp":"2019-03-20T03:55:37.888Z"
}

公共-获取全部ticker信息

获取平台全部币对的最新成交价、买一价、卖一价和24小时交易量的快照信息。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/instruments/ticker

请求示例

GET/api/spot/v3/instruments/ticker

{
    "best_ask": "722220",
    "best_bid": "722210",
    "instrument_id": "BTC-JPY",
    "product_id": "BTC-JPY",
    "last": "722220",
    "last_qty": "0.00136237",
    "ask": "722220",
    "best_ask_size": "0.09207739",
    "bid": "722210",
    "best_bid_size": "3.61314948",
    "open_24h": "735680",
    "high_24h": "736770",
    "low_24h": "716000",
    "base_volume_24h": "18577.2",
    "timestamp": "2019-12-11T07:48:04.014Z",
    "quote_volume_24h": "134899542.8"
}

公共-获取某个ticker信息

获取币对的最新成交价、买一价、卖一价和24小时交易量的快照信息。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/instruments/<instrument-id>/ticker

请求示例

GET/api/spot/v3/instruments/BTC-JPY/ticker

请求参数

{
    "best_ask": "722220",
    "best_bid": "722210",
    "instrument_id": "BTC-JPY",
    "product_id": "BTC-JPY",
    "last": "722220",
    "last_qty": "0.00136237",
    "ask": "722220",
    "best_ask_size": "0.09207739",
    "bid": "722210",
    "best_bid_size": "3.61314948",
    "open_24h": "735680",
    "high_24h": "736770",
    "low_24h": "71600",
    "base_volume_24h": "18577.2",
    "timestamp": "2019-12-11T07:48:04.014Z",
    "quote_volume_24h": "134899542.8"
}

公共-获取成交数据

本接口能查询最近100条数据。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/instruments/<instrument_id>/trades

签名请求示例

GET/api/spot/v3/instruments/LTC-JPY/trades?limit=20

请求参数

[
    {
        "time":"2019-04-12T02:07:30.523Z",
        "timestamp":"2019-04-12T02:07:30.523Z",
        "trade_id":"1296412902",
        "price":"4913.4",
        "size":"0.00990734",
        "side":"buy"
    },
    {
        "time":"2019-04-12T02:07:30.455Z",
        "timestamp":"2019-04-12T02:07:30.455Z",
        "trade_id":"1296412899",
        "price":"4913.2",
        "size":"0.17820096",
        "side":"sell"
    }
]

公共-获取K线数据

获取币对的K线数据。K线数据按请求的粒度分组返回，K线数据最多可获取最近1440条。

限速规则：20次/2s

HTTP请求

GET/api/spot/v3/instruments/<instrument_id>/candles

签名请求示例

GET/api/spot/v3/instruments/BTC-JPY/candles?granularity=86400&start=2019-03-19T16:00:00.000Z&end=2019-03-20T16:00:00.000Z

请求参数

[
    [
        "2019-03-19T16:00:00.000Z",
        "3997.3",
        "4031.9",
        "3982.5",
        "3998.7",
        "26175.21141385"
    ],
    [
        "2019-03-18T16:00:00.000Z",
        "3980.6",
        "4014.6",
        "3968.9",
        "3997.3",
        "33053.48725643"
    ]
]

这里是RestAPI 错误码

公共错误码（30000-31000）

v3API将使用统一30000开头的错误码

公共错误码包括签名以及各个业务线统一的错误码

资金账户错误码（34000-35000）

币币和杠杆错误码（33000-34000）

目前暂不支持杠杆业务，望周知。

WebSocket API

以下是现货V3 WebscoketAPI，除了account有单独频道，其余频道数据对币币用户适用。

概述

WebSocket是HTML5一种新的协议（Protocol）。它实现了客户端与服务器全双工通信， 使得数据可以快速地双向传播。通过一次简单的握手就可以建立客户端和服务器连接， 服务器根据业务规则可以主动推送信息给客户端。其优点如下：

• 客户端和服务器进行数据传输时，请求头信息比较小，大概2个字节。
• 客户端和服务器皆可以主动地发送数据给对方。
• 不需要多次创建TCP请求和销毁，节约宽带和服务器的资源。

强烈建议开发者使用WebSocket API获取市场行情和买卖深度等信息。

地址：wss://connect.okcoin.jp:443/ws/v3

访问时需要科学上网

连接说明：

所有返回数据都进行了压缩，需要用户将接收到的数据进行解压(通过inflate算法进行压缩和解压)。

连接上ws后30s未订阅或订阅后30s内服务器未向用户推送数据，系统会自动断开连接

指令格式

请求格式：

{"op": "<value>", "args": ["<value1>","<value2>"]}

其中 op 的取值为 1--subscribe 订阅； 2-- unsubscribe 取消订阅 ；3--login 登录

args: 取值为频道名，可以定义一个或者多个频道

成功响应格式:

  {"event": "<value>","channel":"<value>"}
  {"table":"channel","data":"[{"<value1>","<value2>"}]"}

其中spot/depth 频道为了区分是首次全量和后续的增量返回格式将会是

{"table":"channel", "action":"<value>","data":"[{"<value1>","<value2>"}]"}

失败响应格式:

{"event":"error","message":"<error_message>","errorCode":"<errorCode>"}

订阅

用户可以选择订阅一个或者多个频道，多个频道总长度不能超过4096个字节

{"op": "subscribe", "args": ["<SubscriptionTopic>"]}

说明 ：op 的取值是 subscribe

args 数组内容为频道名称 ：<channelname>:<filter>

其中`channelname 是以 business/channel组成

现货推送业务business为spot， channel为此业务下每个具体的名称，如果channel的名字不能以一个字母区分将会以 " _ " 进行连接

例：

"spot/ticker:BTC-JPY"

filter 是可筛选数据，具体参考每个频道说明

示例：

send:

{"op": "subscribe", "args": ["spot/ticker:ETH-JPY","spot/candle60s:ETH-JPY"]}

response:

 {"event":"subscribe","channel":"spot/ticker:ETH-JPY"}

 {"event":"subscribe","channel":"spot/candle60s:ETH-JPY"}

 {"table":"spot/ticker","data":[{"instrument_id":"ETH-JPY","last":"8.8","best_bid":"3","best_ask":"8.1","open_24h":"5.1","high_24h":"8.8","low_24h":"3",
 "base_volume_24h":"13.77340909","quote_volume_24h":"78.49886361","timestamp":"2018-12-20T03:13:41.664Z"}]}

 {"table":"spot/candle60s","data":[{"candle":["2018-12-20T06:18:00.000Z","8.8","8.8","8.8","8.8","0"],"instrument_id":"ETH-JPY"}]}

取消订阅

可以取消一个或者多个频道

{"op": "unsubscribe", "args": [<SubscriptionTopic>]}

例如：

请求：

{"op": "unsubscribe", "args": ["spot/ticker:BTC-JPY", "spot/candle60s:BTC-JPY"]}

返回：

{"event":"unsubscribe","channel":"spot/ticker:BTC-JPY"}
{"event":"unsubscribe","channel":"spot/candle60s:BTC-JPY"}

登录

签名方式说明参考API概述里的验证部分

登录订阅格式：

{"op":"login","args":["<api_key>","<passphrase>","<timestamp>","<sign>"]}

响应：

{"event":"login","success":true}

例：

{"op":"login","args":["985d5b66-57ce-40fb-b714-afc0b9787083","123456","1538054050.975",
"7L+zFQ+CEgGu5rzCj4+BdV2/uUHGqddA9pI6ztsRRPs="]}

api_key:为用户申请的APIKey

Passphrase:为申请v3 api时所填写

timestamp:为时间戳 是Unix Epoch时间，单位是秒， 时间戳30秒后会过期 推荐使用time endponit 查询API 服务器的时间，如果你的服务器时间和API 服务器时间有偏差的话

sign:为签名字符串，签名规则参照请求说明（API概述验证部分）

其中timestamp示例:const timestamp = '' + Date.now() / 1000

其中sign 示例 : sign=CryptoJS.enc.Base64.Stringify(CryptoJS.HmacSHA256(timestamp +'GET'+ '/users/self/verify', secret))

method一律默认为'GET'。

requestPath 一律默认为'/users/self/verify'

如果登录失败会自动断开链接

连接限制

连接限制：1次/s

订阅限制：每小时240次

连接上ws后如果一直没有数据返回，30s 后自动断开链接， 建议用户进行以下操作:

1，每次接收到消息后，用户设置一个定时器 ，定时N秒。

2，如果定时器被触发（N 秒内没有收到新消息），发送字符串 'ping'。

3，期待一个文字字符串'pong'作为回应。如果在 N秒内未收到，请发出错误或重新连接。

出现网络问题会自动断开连接

校验和机制

此功能可以帮助用户校验深度数据的准确性

每次推送depth频道的深度数据都有时间戳，且有checksum 校验（即checksum值）。 用户订阅depth 频道首次会接收到Example Response深度，后续推送的都是增量数据。checksum值为：每次增量更新合并后此Example Response深度的前25档bids和asks组成的字符串的crc32值， 用户可以拿自己的checksum的值和订阅的checksum值进行比较，如果不匹配可以重新订阅。

深度合并规则说明： 首次发送Example Response深度数据，后续每次发送增量的数据，拿增量去遍历Example Response中的asks和bids的price ,如果发现有相同价格 则看数量，数量为0删除此深度，数量有变化则替换此数据； 无相同价格则按照顺序排序。

计算说明: checksum的值为有符号整型(32位)

checksum的字符串都是以冒号连接的ask和bid中的price和数量，例如：

例子1：bid和ask成对档的情况下，要校验的字符串为：bid:ask:bid:ask:...

"data": [{
        "instrument_id": "BTC-JPY",
        "asks": [["3366.8", "9", 10],[ "3368","8",3]],
        "bids": [
            ["3366.1", "7", 0],[ "3366","6",3 ]
        ],
        "timestamp": "2018-12-04T09:38:36.300Z",
        "checksum": -1881014294
    }]

该例子对应的checksum字符串为：3366.1:7:3366.8:9:3366:6:3368:8

例子2：bid和ask不成对档的情况 ，要校验的字符串为：bid:ask:ask:ask:...

"data": [{
        "instrument_id": "BTC-JPY",
        "asks": [["3366.8", "9", 10],[ "3368","8",3],[ "3372","8",3 ]],
        "bids": [
            ["3366.1", "7", 0]
        ],
        "timestamp": "2018-12-04T09:38:36.300Z",
        "checksum": 831078360
    }]

此例子对应的checksum String 将会是 3366.1:7:3366.8:9:3368:8:3372:8

depth 频道用户收到推送数据为：

首次Example Response

{
    "table": "spot/depth",
    "action": "partial",
    "data": [{
        "instrument_id": "ETH-JPY",
        "asks": [
            ["8.8", "96.99999966", 1],
            ["9", "39", 3],
            ["9.5", "100", 1],
            ["12", "12", 1],
            ["95", "0.42973686", 3],
            ["11111", "1003.99999795", 1]
        ],
        "bids": [
            ["5", "7", 4],
            ["3", "5", 3],
            ["2.5", "100", 2],
            ["1.5", "100", 1],
            ["1.1", "100", 1],
            ["1", "1004.9998", 1]
        ],
        "timestamp": "2018-12-18T07:27:13.655Z",
        "checksum": 468410539
    }]
}

增量：

{
    "table": "spot/depth",
    "action": "update",
    "data": [{
        "instrument_id": "BTC-JPY",
        "asks": [],
        "bids": [
            ["3983", "789", 0]
        ],
        "timestamp": "2018-12-04T09:38:36.300Z",
        "checksum": -1200119424
    }]
}

频道说明

无需登录的频道包括：行情频道，K线频道，交易数据频道，资金费率频道，限价范围频道，深度数据频道，标记价格频道

需登录的频道包括：用户账户频道，用户交易频道，用户持仓频道

无需登录的频道名称如下：

spot/ticker // 行情数据频道

spot/trade // 交易信息频道

spot/depth //深度数据频道，首次Example Response，后续增量

spot/depth5 //深度数据频道，每次返回前5档

需登录的频道如下

spot/account //用户币币账户信息频道

spot/order //用户交易数据频道

用户币币账户频道

获取币币账户信息，需用用户登录

send示例

{"op": "subscribe", "args": ["spot/account:BTC"]}

其中spot/account为频道名，BTC为currency

{
    "table":"spot/account",
    "data":[
        {
            "balance":"2.215374581132125",
            "available":"1.632774581132125",
            "currency":"JPY",
            "id":"",
            "hold":"0.5826"
        }
    ]
}

用户交易频道

获取用户交易数据，需用用户登录

send示例

{"op": "subscribe", "args": ["spot/order:LTC-JPY"]}

其中spot/order为频道名，LTC-JPY为instrument_id

{
    "table":"spot/order",
    "data":[
        {
            "client_oid":"",
            "filled_notional":"0",
            "filled_size":"0",
            "instrument_id":"LTC-JPY",
            "last_fill_px":"0",
            "last_fill_qty":"0",
            "last_fill_time":"1970-01-01T00:00:00.000Z",
            "margin_trading":"1",
            "notional":"",
            "order_id":"3576398568830976",
            "order_type":"0",
            "price":"5.826",
            "side":"buy",
            "size":"0.1",
            "state":"0",
            "status":"open",
            "timestamp":"2019-09-24T06:45:11.394Z",
            "type":"limit",
            "created_at":"2019-09-24T06:45:11.394Z"
        }
    ]
}

用户委托策略频道

用户委托策略频道

send示例

{"op": "subscribe", "args": ["spot/order_algo:LTC-JPY"]}

其中spot/order_algo为频道名，LTC-JPY为instrument_id

{
  "table": "spot/order_algo",
  "data": [
    {
      "algo_id": "7992531393232896",
      "cancel_code": "",
      "created_at": "2021-11-12T04:45:50.632Z",
      "instrument_id": "ETH-JPY",
      "mode": "1",
      "order_side": "3",
      "order_type": "5",
      "side": "sell",
      "size": "0.1",
      "sl_price": "3",
      "sl_trigger_price": "4",
      "sl_trigger_type": "1",
      "status": "1",
      "timestamp": "2021-11-12T04:45:50.632Z",
      "tp_price": "487601",
      "tp_trigger_price": "487600",
      "tp_trigger_type": "1",
      "trigger_side": ""
    }
  ]
}

公共-Ticker频道

获取现货最新成交价、买一价、卖一价和24交易量，每100ms推送一次数据。

send示例

{"op": "subscribe", "args": ["spot/ticker:ETH-JPY"]}

其中spot/ticker为频道名，ETH-JPY为instrument_id

{
    "table":"spot/ticker",
    "data":[
        {
            "instrument_id":"ETH-JPY",
            "last":"146.24",
            "last_qty":"0.082483",
            "best_bid":"146.24",
            "best_bid_size":"0.006822",
            "best_ask":"146.25",
            "best_ask_size":"80.541709",
            "open_24h":"147.17",
            "high_24h":"147.48",
            "low_24h":"143.88",
            "base_volume_24h":"117387.58",
            "quote_volume_24h":"17159427.21",
            "timestamp":"2019-12-11T02:31:40.436Z"
        }
    ]
}

公共-K线频道

获取现货的K线数据，每500ms推送一次数据。

频道列表：

spot/candle60s // 1分钟K线数据频道

spot/candle180s // 3分钟K线数据频道

spot/candle300s // 5分钟K线数据频道

spot/candle900s // 15分钟K线数据频道

spot/candle1800s // 30分钟K线数据频道

spot/candle3600s // 1小时K线数据频道

spot/candle7200s // 2小时K线数据频道

spot/candle14400s // 4小时K线数据频道

spot/candle21600s // 6小时K线数据频道

spot/candle43200s // 12小时K线数据频道

spot/candle86400s // 1day K线数据频道

spot/candle604800s // 1week K线数据频道

send示例

{"op": "subscribe", "args": ["spot/candle60s:ETH-JPY"]}

其中spot/candle60s为频道名，ETH-JPY为instrument_id

{
    "table":"spot/candle60s",
    "data":[
        {
            "candle":[
                "2019-04-16T10:49:00.000Z",
                "162.03",
                "162.04",
                "161.96",
                "161.98",
                "336.452694"
            ],
            "instrument_id":"ETH-JPY"
        }
    ]
}

公共-交易频道

获取最近的成交数据，无需用户登录，有成交数据就推送。

send示例

{"op": "subscribe", "args": ["spot/trade:ETH-JPY"]}

其中spot/trade为频道名，ETH-JPY为instrument_id

{
    "table": "spot/trade",
    "data": [{
        "instrument_id": "ETH-JPY",
        "price": "162.12",
        "side": "buy",
        "size": "11.085",
        "timestamp": "2019-05-06T06:51:24.389Z",
        "trade_id": "1210447366"
    }]
}

公共-5档深度频道

每次返回前五档的深度数据，此数据为每100毫秒的快照数据，即每隔100毫秒，快照当前时刻市场订单簿的5档深度数据并推送。

send示例

{"op": "subscribe", "args": ["spot/depth5:ETH-JPY"]}

其中spot/depth5为频道名，ETH-JPY为instrument_id

{
    "table":"spot/depth5",
    "data":[
        {
            "asks":[
                [
                    "161.96",
                    "7.37567",
                    3
                ],
                [
                    "161.97",
                    "1.308",
                    1
                ],
                [
                    "161.98",
                    "2.463509",
                    1
                ],
                [
                    "161.99",
                    "5.185",
                    2
                ],
                [
                    "162",
                    "29.184592",
                    5
                ]
            ],
            "bids":[
                [
                    "161.94",
                    "4.552355",
                    1
                ],
                [
                    "161.91",
                    "7.949",
                    3
                ],
                [
                    "161.9",
                    "2.213",
                    1
                ],
                [
                    "161.89",
                    "11.999998",
                    1
                ],
                [
                    "161.88",
                    "6.585142",
                    3
                ]
            ],
            "instrument_id":"ETH-JPY",
            "timestamp":"2019-04-16T11:03:03.712Z"
        }
    ]
}

公共-400档深度频道

订阅后首次返回市场订单簿的400档深度数据并推送；然后每隔100毫秒，快照这个时间段内有更改的订单簿数据，并推送。

send示例

{"op": "subscribe", "args": ["spot/depth:ETH-JPY"]}

其中spot/depth为频道名，ETH-JPY为instrument_id

首次Example Response
{
    "table":"spot/depth",
    "action":"partial",
    "data":[
        {
            "instrument_id":"ETH-JPY",
            "asks":[
                [
                    "162.5",
                    "14.29884",
                    2
                ],
                [
                    "162.51",
                    "2.084362",
                    1
                ],
               ...

                [
                    "168.51",
                    "7.760755",
                    2
                ],
                [
                    "168.57",
                    "0.02",
                    1
                ]
            ],
            "bids":[
                [
                    "162.49",
                    "1.556106",
                    3
                ],
                [
                    "162.47",
                    "0.00913",
                    1
                ],
               ...

                [
                    "155.15",
                    "70",
                    1
                ],
                [
                    "155.13",
                    "3",
                    1
                ]
            ],
            "timestamp":"2019-04-16T10:17:28.507Z",
            "checksum":1141851215
        }
    ]
}

增量：
{
    "table":"spot/depth",
    "action":"update",
    "data":[
        {
            "instrument_id":"ETH-JPY",
            "asks":[
                [
                    "162.5",
                    "0",
                    0
                ],
                [
                    "162.61",
                    "1.209",
                    2
                ],
                [
                    "168.69",
                    "0.006",
                    1
                ],
                [
                    "168.73",
                    "0.002082",
                    1
                ]
            ],
            "bids":[
                [
                    "162.49",
                    "1.512544",
                    2
                ],
                [
                    "162.47",
                    "0.05333",
                    2
                ],
                [
                    "162.46",
                    "14.608508",
                    3
                ],
                [
                    "162.43",
                    "10.61874",
                    3
                ],
                [
                    "162.41",
                    "27.303906",
                    2
                ],
                [
                    "162.4",
                    "14.762929",
                    6
                ],
                [
                    "162.39",
                    "11.045909",
                    1
                ],
                [
                    "162.36",
                    "19.230907",
                    8
                ],
                [
                    "162.31",
                    "3.927598",
                    4
                ],
                [
                    "162.3",
                    "5.353085",
                    5
                ],
                [
                    "162.29",
                    "6.569261",
                    12
                ],
                [
                    "162.25",
                    "8.308575",
                    3
                ]
            ],
            "timestamp":"2019-04-16T10:17:29.045Z",
            "checksum":227291232
        }
    ]
}

这里是Websocket错误码

error message 格式：

{"event":"error"," message":" ","errorCode":""}

错误码示例

常见问题

1.API下单撤单总的数量有限制吗？

没有限制的

2.Http状态码429是怎样造成的？

超过了访问频率，建议降低频率试试

3.账户v3生成新的apiKey，必须要用v3版api去发请求吗？

是的，v1和v3的api是独立的，v1的key去调用v1的接口，v3的key去调用v3的接口

4.撤单成功后,返回的订单号，后面调订单查询接口,就查不到这个订单信息？

已撤销的未成交单子只保留最近2个小时

5.一个账户最多能申请多少个apikey？

10个

6.K线接口能拿到多久的历史数据？

K线最多只能获取最近2000条数据

7.OKCoinJapan的api的访问频率是根据什么限制的？

公共数据是根据ip限制，个人数据是根据Userid限制

8.请求api报timeout的错误，是什么问题？

网络超时，检查下网络，建议使用东京AWS服务器

9.同一个账户里的不同的key，返回的账户信息数据，会不同吗？

数据是相同的，指定的是同一个账户。

10.v3创建apikey的时候，必须需要填写ip地址才可以创建吗？

是的，为了增加账户的安全性，申请apikey时必须绑定ip。

11.v3api下单，amount必须是以张为单位的吗？

是的，amount必须是以张为单位，最少是1张，或者1的整数倍。

12.Api调用接口报超过访问频率会被封ip吗？封多久？

不会的，降低访问频率就可以

问题反馈

如果您有任何api相关问题，意见或者建议，请点此链接反馈：(请标明是API v3 ), 我们会及时处理您的问题。