Introduction
GMO Coin provides a Public API that does not require authentication and a Private API that requires authentication using an API key.
- All requests from the client to the API are HTTPS communication.
//Request examples are tested with Node.js v21.0.0.
#Request examples are tested with Python 3.12.0.
//Request examples are tested with Go 1.21.3.
#Request examples are tested with Ruby 3.2.2.
//Request examples are tested with Kotlin 1.9.10.
<?php
//Request examples are tested with PHP 8.2.11.
//Request examples are tested with rustc 1.73.0.
--Request examples are tested with ghc 9.8.1.
//Request examples are tested with .NET Framework 8.0.1.
//Request examples are tested with Swift 5.8.1.
Endpoint
- Public API:
https://forex-api.coin.z.com/public - Public WebSocket API:
wss://forex-api.coin.z.com/ws/public - Private API:
https://forex-api.coin.z.com/private - Private WebSocket API:
wss://forex-api.coin.z.com/ws/private
Version
Current version: v1
API Limiting
API usage Limits are below:
Public WebSocket API Limiting
- 1 request (subscribe/unsubscribe) per second from each IP address for Public WebSocket API.
Private API Limiting
- Private API's limits are subject to change without prior notice.
- If you enable the IP restriction feature on the membership site, it will deny any API calling that comes from a non-registered IP.
- Only features that are specified on the membership site when API key was issued can be called.
| Description |
|---|
| Maximum 6 GET requests per second. Maximum 1 POST requests per second. |
Private WebSocket API Limiting
- Private WebSocket API is limited to maximum 1 request (subscribe/unsubscribe) per second for each IP address.
- If you enable the IP restriction feature on the membership site, it will deny any API calling that comes from a non-registered IP.
- Only features specified at the time of issuing the API key can be subscribed.
Other
We may restrict API usage due to any of the following reasons.
- To automatically limit the flow rate when our entire system experiences overload.
- We have determined the user's API usage may be causing an overload on our system.
- We have determined that users are repeatedly placing orders to intentionally overload our system.
Opening New Accounts
If you don't have a forex account Sign up for free
Creating API Keys
After opening forex account, you can create forex API keys from the membership site.
When you create a forex API key, you can set a permission for each functionality.
You can start 30 days free trial with creating forex API Keys.
Please check API fees for "Order" and "Change Order" via API here.
Authentication
Private API
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://END_POINT_URL';
const path = '/v1/PATH';
const reqBody = JSON.stringify({});
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://END_POINT_URL'
path = '/v1/PATH'
reqBody = {}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
parameters = {}
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.get(endPoint + path, headers=headers, params=parameters)
print (res.json())
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://END_POINT_URL"
path := "/v1/PATH"
reqBody := (`{}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://END_POINT_URL'
path = '/v1/PATH'
reqBody = {}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://END_POINT_URL"
var path = "/v1/PATH"
var reqBody = """{}"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://END_POINT_URL';
$path = '/v1/PATH';
$reqBody = '{}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
order().unwrap();
}
fn order() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://END_POINT_URL";
let path = "/v1/PATH";
let parameters = json!({});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://END_POINT_URL"
path :: S.String
path = "/v1/PATH"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {}
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = Sample();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> Sample()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://END_POINT_URL";
const string path = "/v1/PATH";
var reqBody = "{}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/PATH"
let reqBodyStr = """
{}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
HTTP header requires to include information with using API key and API secret below:
- API-KEY: Access key that is issued on the membership site
- API-TIMESTAMP: The request's Unix Timestamp
- API-SIGN: Signature generated for each request with the following method
API-SIGN is the resulting HMAC-SHA256 hash of the API-TIMESTAMP, HTTP method, request path, and request body concatenated together as a character string, created using your API secret.
Private WebSocket API
Using a Private API to get an access token. The way of authentication for the Private API is the same as the other Private API.
Public API
Service Status
Request example:
const axios = require('axios');
const endPoint = 'https://forex-api.coin.z.com/public';
const path = '/v1/status';
axios.get(endPoint + path)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
endPoint = 'https://forex-api.coin.z.com/public'
path = '/v1/status'
response = requests.get(endPoint + path)
print(response.json())
package main
import (
"fmt"
"io"
"net/http"
"encoding/json"
"bytes"
)
func main() {
endPoint := "https://forex-api.coin.z.com/public"
path := "/v1/status"
response, _ := http.Get(endPoint + path)
body, _ := io.ReadAll(response.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'uri'
require 'json'
endPoint = 'https://forex-api.coin.z.com/public'
path = '/v1/status'
uri = URI.parse(endPoint + path)
req = Net::HTTP::Get.new(uri.to_s)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
fun main() {
var endPoint = "https://forex-api.coin.z.com/public"
var path = "/v1/status"
var method = "GET"
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$endPoint = 'https://forex-api.coin.z.com/public';
$path = '/v1/status';
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
extern crate reqwest;
fn main() {
let body = reqwest::blocking::get("https://forex-api.coin.z.com/public/v1/status").
expect("Failed")
.text();
println!("body = {:?}", body);
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.ByteString.Lazy.Char8 as S8
import Network.HTTP.Simple
main :: IO ()
main = do
response <- httpJSON "https://forex-api.coin.z.com/public/v1/status"
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = Status();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<string> Status()
{
const string endpoint = "https://forex-api.coin.z.com/public";
const string path = "/v1/status";
return await HttpClient.GetStringAsync(endpoint + path);
}
}
import Foundation
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let endPoint : String = "https://forex-api.coin.z.com/public"
let path : String = "/v1/status"
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = "GET"
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": {
"status": "OPEN"
},
"responsetime": "2019-03-19T02:15:06.001Z"
}
Gets the service status of GMO Coin.
Request
GET /public/v1/status
Parameters
None
Response
| Property Name | Value | Description |
|---|---|---|
| status | string | Service status: MAINTENANCE CLOSE OPEN |
Ticker
Request example:
const axios = require('axios');
const endPoint = 'https://forex-api.coin.z.com/public';
const path = '/v1/ticker';
axios.get(endPoint + path)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
endPoint = 'https://forex-api.coin.z.com/public'
path = '/v1/ticker'
response = requests.get(endPoint + path)
print(json.dumps(response.json(), indent=2))
package main
import (
"fmt"
"io"
"net/http"
"encoding/json"
"bytes"
)
func main() {
endPoint := "https://forex-api.coin.z.com/public"
path := "/v1/ticker"
response, _ := http.Get(endPoint + path)
body, _ := io.ReadAll(response.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'uri'
require 'json'
endPoint = 'https://forex-api.coin.z.com/public'
path = '/v1/ticker'
uri = URI.parse(endPoint + path)
req = Net::HTTP::Get.new(uri.to_s)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
fun main() {
var endPoint = "https://forex-api.coin.z.com/public"
var path = "/v1/ticker"
var method = "GET"
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$endPoint = 'https://forex-api.coin.z.com/public';
$path = '/v1/ticker';
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
extern crate reqwest;
fn main() {
let body = reqwest::blocking::get("https://forex-api.coin.z.com/public/v1/ticker").
expect("Failed")
.text();
println!("body = {:?}", body);
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.ByteString.Lazy.Char8 as S8
import Network.HTTP.Simple
main :: IO ()
main = do
request' <- parseRequest "https://forex-api.coin.z.com/public/v1/ticker"
let request
= setRequestMethod "GET"
$ setRequestSecure True
$ setRequestPort 443
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = Ticker();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<string> Ticker()
{
const string endpoint = "https://forex-api.coin.z.com/public";
const string path = "/v1/ticker";
return await HttpClient.GetStringAsync(endpoint + path);
}
}
import Foundation
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let endPoint : String = "https://forex-api.coin.z.com/public"
let path : String = "/v1/ticker"
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = "GET"
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"ask": "137.644",
"bid": "137.632",
"symbol": "USD_JPY",
"timestamp": "2018-03-30T12:34:56.789671Z",
"status": "OPEN"
},
{
"symbol": "EUR_JPY",
"ask": "149.221",
"bid": "149.181",
"timestamp": "2023-05-19T02:51:24.516493Z",
"status": "OPEN"
}
],
"responsetime": "2019-03-19T02:15:06.014Z"
}
Gets the latest rates of all symbols.
Request
GET /public/v1/ticker
Parameters
None
Response
| Property Name | Value | Description |
|---|---|---|
| symbol | string | The handling symbols are here |
| ask | string | Current ask price. |
| bid | string | Current bid price. |
| timestamp | string | Timestamp of current rate. |
| status | string | Service status: CLOSE OPEN |
KLine Data
Request example:
const axios = require('axios');
const endPoint = 'https://forex-api.coin.z.com/public';
const path = '/v1/klines?symbol=USD_JPY&priceType=ASK&interval=1min&date=20231028';
axios.get(endPoint + path)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
endPoint = 'https://forex-api.coin.z.com/public'
path = '/v1/klines?symbol=USD_JPY&priceType=ASK&interval=1min&date=20231028'
response = requests.get(endPoint + path)
print(json.dumps(response.json(), indent=2))
package main
import (
"fmt"
"io"
"net/http"
"encoding/json"
"bytes"
)
func main() {
endPoint := "https://forex-api.coin.z.com/public"
path := "/v1/klines?symbol=USD_JPY&priceType=ASK&interval=1min&date=20231028"
response, _ := http.Get(endPoint + path)
body, _ := io.ReadAll(response.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'uri'
require 'json'
endPoint = 'https://forex-api.coin.z.com/public'
path = '/v1/klines?symbol=USD_JPY&priceType=ASK&interval=1min&date=20231028'
uri = URI.parse(endPoint + path)
req = Net::HTTP::Get.new(uri.to_s)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
fun main() {
var endPoint = "https://forex-api.coin.z.com/public"
var path = "/v1/klines?symbol=USD_JPY&priceType=ASK&interval=1min&date=20231028"
var method = "GET"
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$endPoint = 'https://forex-api.coin.z.com/public';
$path = '/v1/klines?symbol=USD_JPY&priceType=ASK&interval=1min&date=20231028';
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
extern crate reqwest;
fn main() {
let body = reqwest::blocking::get("https://forex-api.coin.z.com/public/v1/klines?symbol=USD_JPY&priceType=ASK&interval=1min&date=20231028").
expect("Failed")
.text();
println!("body = {:?}", body);
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.ByteString.Lazy.Char8 as S8
import Network.HTTP.Simple
main :: IO ()
main = do
request' <- parseRequest "https://forex-api.coin.z.com/public/v1/klines"
let request
= setRequestMethod "GET"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestQueryString [("symbol", Just "USD_JPY"), ("priceType", Just "ASK"), ("interval", Just "1min"), ("date", Just "20230708")]
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = Klines();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<string> Klines()
{
const string endpoint = "https://forex-api.coin.z.com/public";
const string path = "/v1/klines?symbol=USD_JPY&priceType=ASK&interval=1min&date=20231028";
return await HttpClient.GetStringAsync(endpoint + path);
}
}
import Foundation
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let endPoint : String = "https://forex-api.coin.z.com/public"
let path : String = "/v1/klines?symbol=USD_JPY&priceType=ASK&interval=1min&date=20231028"
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = "GET"
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"openTime":"1618588800000",
"open":"141.365",
"high":"141.368",
"low":"141.360",
"close":"141.362"
},
{
"openTime":"1618588860000",
"open":"141.362",
"high":"141.369",
"low":"141.361",
"close":"141.365"
}
],
"responsetime": "2023-07-08T22:28:07.980Z"
}
Gets a market's OHLC of the specified symbol.
Request
GET /public/v1/klines
Parameters
- Parameter type: query
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| symbol | string | Required |
The handling symbols are here |
| priceType | string | Required |
Specify BID or ASK |
| interval | string | Required |
1min 5min 10min 15min 30min 1hour 4hour 8hour 12hour 1day 1week 1month |
| date | string | Required |
Acceptable data formats: YYYYMMDD YYYYIf YYYYMMDD , the following interval values are supported: 1min 5min 10min 15min 30min 1hour ※The date should be equal to or after 20231028. Date will be renewed at JST 6:00. If YYYY , the following interval values are supported: 4hour 8hour 12hour 1day 1week 1month ※The date should be equal to or after the release date of each symbol. The release date is here. |
Response
| Property Name | Value | Description |
|---|---|---|
| openTime | string | Start unix timestamp(milliseconds) |
| open | string | Open price |
| high | string | High price |
| low | string | Low price |
| close | string | Close price |
Trade rules
Request example:
const axios = require('axios');
const endPoint = 'https://forex-api.coin.z.com/public';
const path = '/v1/symbols';
axios.get(endPoint + path)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
endPoint = 'https://forex-api.coin.z.com/public'
path = '/v1/symbols'
response = requests.get(endPoint + path)
print(json.dumps(response.json(), indent=2))
package main
import (
"fmt"
"io"
"net/http"
"encoding/json"
"bytes"
)
func main() {
endPoint := "https://forex-api.coin.z.com/public"
path := "/v1/symbols"
response, _ := http.Get(endPoint + path)
body, _ := io.ReadAll(response.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'uri'
require 'json'
endPoint = 'https://forex-api.coin.z.com/public'
path = '/v1/symbols'
uri = URI.parse(endPoint + path)
req = Net::HTTP::Get.new(uri.to_s)
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
fun main() {
var endPoint = "https://forex-api.coin.z.com/public"
var path = "/v1/symbols"
var method = "GET"
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$endPoint = 'https://forex-api.coin.z.com/public';
$path = '/v1/symbols';
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
extern crate reqwest;
fn main() {
let body = reqwest::blocking::get("https://forex-api.coin.z.com/public/v1/symbols").
expect("Failed")
.text();
println!("body = {:?}", body);
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.ByteString.Lazy.Char8 as S8
import Network.HTTP.Simple
main :: IO ()
main = do
request' <- parseRequest "https://forex-api.coin.z.com/public/v1/symbols"
let request
= setRequestMethod "GET"
$ setRequestSecure True
$ setRequestPort 443
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = Orderbooks();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<string> Orderbooks()
{
const string endpoint = "https://forex-api.coin.z.com/public";
const string path = "/v1/symbols";
return await HttpClient.GetStringAsync(endpoint + path);
}
}
import Foundation
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let endPoint : String = "https://forex-api.coin.z.com/public"
let path : String = "/v1/symbols"
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = "GET"
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"symbol": "USD_JPY",
"minopenOrderSize": "10000",
"maxOrderSize": "500000",
"sizeStep": "1",
"tickSize": "0.001"
}
],
"responsetime": "2022-12-15T19:22:23.792Z"
}
Gets trade rules.
Request
GET /public/v1/symbols
Parameters
None
Response
| Property Name | Value | Description |
|---|---|---|
| symbol | string | The handling symbols are here |
| minOpenOrderSize | string | Minimum new order size |
| maxOrderSize | string | Maximum order size |
| sizeStep | string | Minimum order value |
| tickSize | string | Tick size |
Public WebSocket API
- A ping will be sent from the server to a client once per minute. If there's no response (pong) from a client 3 consecutive times, then the WebSocket will be disconnected automatically.
Ticker
Request example:
const WebSocket = require("ws");
const ws = new WebSocket("wss://forex-api.coin.z.com/ws/public/v1");
ws.on("open", () => {
const message = JSON.stringify(
{
"command": "subscribe",
"channel": "ticker",
"symbol": "USD_JPY"
});
ws.send(message);
});
ws.on("message", (data) => {
console.log("WebSocket message: ", data);
});
import json
import websocket
websocket.enableTrace(True)
ws = websocket.WebSocketApp('wss://forex-api.coin.z.com/ws/public/v1')
def on_open(self):
message = {
"command": "subscribe",
"channel": "ticker",
"symbol": "USD_JPY"
}
ws.send(json.dumps(message))
def on_message(self, message):
print(message)
ws.on_open = on_open
ws.on_message = on_message
ws.run_forever()
package main
import (
"fmt"
"golang.org/x/net/websocket"
"encoding/json"
"bytes"
)
func main() {
wsUrl := "wss://forex-api.coin.z.com/ws/public/v1"
origin := "https://forex-api.coin.z.com"
sendMsg := (`{
"command": "subscribe",
"channel": "ticker",
"symbol": "USD_JPY"
}`)
var receiveMsg string
ws, _ := websocket.Dial(wsUrl, "", origin)
websocket.Message.Send(ws, sendMsg)
for {
websocket.Message.Receive(ws, &receiveMsg)
var buf bytes.Buffer
json.Indent(&buf, []byte(receiveMsg), "", " ")
fmt.Println(buf.String())
}
}
require "faye/websocket"
require "eventmachine"
require 'json'
EM.run {
ws = Faye::WebSocket::Client.new("wss://forex-api.coin.z.com/ws/public/v1")
ws.on :open do |event|
message = {
:command => "subscribe",
:channel => "ticker",
:symbol => 'USD_JPY'
}
ws.send(message.to_json)
end
ws.on :message do |event|
puts event.data
end
}
import io.ktor.client.HttpClient
import io.ktor.client.features.websocket.WebSockets
import io.ktor.client.features.websocket.webSocket
import io.ktor.http.cio.websocket.Frame
import io.ktor.http.cio.websocket.readText
import kotlinx.coroutines.runBlocking
import org.json.JSONObject
fun main() {
var wsUrl = "wss://forex-api.coin.z.com/ws/public/v1"
var sendMsg = """
{"command": "subscribe",
"channel": "ticker",
"symbol": "USD_JPY"}
"""
val client = HttpClient {
install(WebSockets)
}
runBlocking {
client.webSocket(
urlString = wsUrl
) {
send(Frame.Text(sendMsg))
while (true) {
val frame = incoming.receive()
when (frame) {
is Frame.Text -> println(JSONObject(frame.readText()).toString(2))
else -> {}
}
}
}
}
}
<?php
// Required installing ratchet/pawl with a command below before running the code.
// composer require ratchet/pawl
require __DIR__ . '/vendor/autoload.php';
$loop = \React\EventLoop\Factory::create();
$reactConnector = new \React\Socket\Connector($loop);
$connector = new \Ratchet\Client\Connector($loop, $reactConnector);
$connector("wss://forex-api.coin.z.com/ws/public/v1")->then(function (Ratchet\Client\WebSocket $conn) use ($connector, $loop) {
$conn->on('message', function (\Ratchet\RFC6455\Messaging\MessageInterface $msg) use ($conn) {
echo "{$msg}\n";
});
$conn->on('close', function ($code = null, $reason = null) {
echo "Connection closed ({$code} - {$reason})\n";
});
$conn->send('{ "command" : "subscribe", "channel" : "ticker", "symbol": "USD_JPY" }');
}, function (\Exception $e) use ($loop) {
echo "Could not connect: {$e->getMessage()}\n";
$loop->stop();
});
$loop->run();
#![deny(warnings)]
extern crate tungstenite;
extern crate url;
use tungstenite::{connect, Message};
use url::Url;
fn main() {
ticker_ws();
}
fn ticker_ws() {
let (mut socket, _response) =
connect(Url::parse("wss://forex-api.coin.z.com/ws/public/v1").unwrap()).expect("Can't connect");
socket
.write_message(Message::Text("{ \"command\" : \"subscribe\", \"channel\": \"ticker\", \"symbol\": \"USD_JPY\" }".into()))
.unwrap();
loop {
let msg = socket.read_message().expect("Error reading message");
println!("{}", msg);
}
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Control.Concurrent (forkIO)
import Control.Monad (forever, unless)
import Control.Monad.Trans (liftIO)
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Network.Socket (withSocketsDo)
import qualified Network.WebSockets as WS
import qualified Wuss as WSS (runSecureClient)
app :: WS.ClientApp ()
app conn = do
putStrLn "Connected!"
WS.sendTextData conn ("{ \"command\" : \"subscribe\", \"channel\": \"ticker\", \"symbol\": \"USD_JPY\" }" :: Text)
_ <- forkIO $ forever $ do
msg <- WS.receiveData conn
liftIO $ T.putStrLn msg
let loop = do
line <- T.getLine
unless (T.null line) $ WS.sendTextData conn line >> loop
loop
WS.sendClose conn ("msgData" :: Text)
main :: IO ()
main = withSocketsDo $ WSS.runSecureClient "forex-api.coin.z.com" 443 "/ws/public/v1" app
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
class Example
{
public static void Main(string[] args)
{
var task = Ticker();
task.Wait();
}
static async Task Ticker()
{
const string endpoint = "wss://forex-api.coin.z.com/ws/public/v1";
const string message = "{ \"command\" : \"subscribe\", \"channel\": \"ticker\", \"symbol\": \"USD_JPY\" }";
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(endpoint), CancellationToken.None);
var messageBytes = Encoding.UTF8.GetBytes(message);
await client.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, true,
CancellationToken.None);
while (client.State == WebSocketState.Open)
{
var incomingData = new byte[1024];
var result = await client.ReceiveAsync(new ArraySegment<byte>(incomingData), CancellationToken.None);
Console.WriteLine(Encoding.UTF8.GetString(incomingData, 0, result.Count));
}
}
}
}
// WebSocket4Net example
using System;
using WebSocket4Net;
class Example
{
static WebSocket websocket;
static void Main(string[] args)
{
websocket = new WebSocket("wss://forex-api.coin.z.com/ws/public/v1");
websocket.Opened += Websocket_Opened;
websocket.MessageReceived += Websocket_MessageReceived;
websocket.Open();
Console.Read();
}
private static void Websocket_Opened(object sender, EventArgs e)
{
const string message = "{ \"command\" : \"subscribe\", \"channel\": \"ticker\", \"symbol\": \"USD_JPY\" }";
websocket.Send(message);
}
private static void Websocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
Console.WriteLine(e.Message);
}
}
import Foundation
extension URLSessionWebSocketTask.Message {
var prettyPrintedJSONString: NSString? {
switch self {
case .string(let text):
guard let object = try? JSONSerialization.jsonObject(with: text.data(using: .utf8)!, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
default:
return nil
}
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let url = URL(string: "wss://forex-api.coin.z.com/ws/public/v1")!
let urlSession = URLSession(configuration: .default)
let webSocketTask = urlSession.webSocketTask(with: url)
webSocketTask.resume()
let message = URLSessionWebSocketTask.Message.string("""
{
"command": "subscribe",
"channel": "ticker",
"symbol": "USD_JPY"
}
""")
webSocketTask.send(message) { error in
if let error = error {
print(error)
}
}
webSocketTask.receive { result in
switch result {
case .failure(let error):
print(error)
case .success(let message):
print(message.prettyPrintedJSONString!)
dispatchGroup.leave()
}
}
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"symbol": "USD_JPY",
"ask": "140.534",
"bid": "140.502",
"timestamp": "2018-03-30T12:34:56.789984Z",
"status": "OPEN"
}
Gets the latest rates of the specified symbol.
After subscribe, tickers start to be sent.
Parameters
- Parameter type: JSON
| Property Name | Type | Required | Available Values |
|---|---|---|---|
| command | string | Required |
subscribe unsubscribe |
| channel | string | Required |
ticker |
| symbol | string | Required |
The handling symbols are here |
Response
| Property Name | Value | Description |
|---|---|---|
| symbol | string | The handling symbols are here |
| ask | string | Current ask price. |
| bid | string | Current bid price. |
| timestamp | string | Timestamp of current rate. |
| status | string | Service status: CLOSE OPEN |
- There is no Response when
unsubscribeis requested.
Private API
Assets
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'GET';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/account/assets';
const text = timestamp + method + path;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.get(endPoint + path, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/account/assets'
text = timestamp + method + path
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.get(endPoint + path, headers=headers)
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "GET"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/account/assets"
text := timestamp + method + path
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, nil)
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/account/assets'
text = timestamp + method + path
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Get.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "GET"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/account/assets"
var text = timestamp + method + path
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'GET';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/account/assets';
$text = $timestamp . $method . $path;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$headers = array(
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
assets().unwrap();
}
fn assets() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "GET";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/account/assets";
let text = format!("{}{}{}", timestamp, method, path);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.get(&(endpoint.to_string() + path))
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "GET"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/account/assets"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "GET"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = Assets();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> Assets()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "GET";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/account/assets";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
{
var text = timestamp + method + path;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "GET"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/account/assets"
let text = timestamp + method + path
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"equity": "120947776",
"availableAmount": "89717102",
"balance": "116884885",
"estimatedTradeFee": "766.5",
"margin": "31227908",
"marginRatio": "406.3",
"positionLossGain": "3884065.046",
"totalSwap": "178825.439",
"transferableAmount": "85654212"
}
],
"responsetime": "2019-03-19T02:15:06.055Z"
}
Retrieves asset data.
Request
GET /private/v1/account/assets
Parameters
None
Response
| Property Name | Value | Description |
|---|---|---|
| equity | string | Market value |
| availableAmount | string | Available amount |
| balance | string | Cash balance |
| estimatedTradeFee | string | Estimated trade fee |
| margin | string | Margin |
| marginRatio | string | Margin ratio |
| positionLossGain | string | Appraisal loss |
| totalSwap | string | Unsettled swap |
| transferableAmount | string | Transferable amount |
Orders
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'GET';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/orders';
const parameters = '?orderId=123456789,223456789';
const text = timestamp + method + path;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.get(endPoint + path + parameters, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/orders'
text = timestamp + method + path
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
parameters = { "orderId": "123456789,223456789" }
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.get(endPoint + path, headers=headers, params=parameters)
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "GET"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/orders"
parameters := "?orderId=123456789,223456789"
text := timestamp + method + path
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path+parameters, nil)
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/orders'
parameters = {
:orderId => '123456789,223456789'
}
text = timestamp + method + path
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
uri.query = URI.encode_www_form(parameters)
req = Net::HTTP::Get.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "GET"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/orders"
var parameters = "?orderId=123456789,223456789"
var text = timestamp + method + path
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path + parameters)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'GET';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/orders';
$parameters = '?orderId=123456789,223456789';
$text = $timestamp . $method . $path;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path . $parameters);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$headers = array(
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use std::collections::HashMap;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
orders().unwrap();
}
fn orders() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "GET";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/orders";
let mut parameters = HashMap::new();
parameters.insert("orderId", "123456789,223456789");
let text = format!("{}{}{}", timestamp, method, path);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.get(&(endpoint.to_string() + path))
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.query(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "GET"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/orders"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "GET"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestQueryString [("orderId", Just "123456789,223456789")]
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = Orders();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> Orders()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "GET";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/orders";
const string parameters = "?orderId=123456789,223456789";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path + parameters))
{
var text = timestamp + method + path;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "GET"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/orders"
let parameters = "?orderId=123456789,223456789"
let text = timestamp + method + path
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path + parameters)!)
request.httpMethod = method
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": {
"list": [
{
"rootOrderId": 223456789,
"clientOrderId": "sygngz1234",
"orderId": 223456789,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "NORMAL",
"executionType": "LIMIT",
"settleType": "OPEN",
"size": "10000",
"price": "140",
"status": "EXECUTED",
"expiry" : "20201113",
"timestamp": "2020-10-14T20:18:59.343Z"
},
{
"rootOrderId": 123456789,
"orderId": 123456789,
"symbol": "CAD_JPY",
"side": "SELL",
"orderType": "NORMAL",
"executionType": "LIMIT",
"settleType": "CLOSE",
"size": "10000",
"price": "110",
"status": "CANCELED",
"cancelType": "USER",
"expiry" : "20201113",
"timestamp": "2020-10-14T20:18:59.343Z"
}
]
},
"responsetime": "2019-03-19T02:15:06.059Z"
}
Gets the specified order id's order information.
- One of
rootOrderIdorderIdis required. Both cannot be set at the same time.
Request
GET /private/v1/orders
Parameters
- Parameter type: query
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| rootOrderId | number | * |
Either rootOrderId or orderId is required.※A comma-separated list of order ids. The maximum number of order ids is 10. |
| orderId | number | * |
Either rootOrderId or orderId is required.※A comma-separated list of order ids. The maximum number of order ids is 10. |
Response
| Property Name | Value | Description |
|---|---|---|
| rootOrderId | number | Root order id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| orderType | string | Order Type: NORMAL OCO IFD IFDOCO LOSSCUT |
| executionType | string | Execution Type: MARKET LIMIT STOP |
| settleType | string | Settlement Type: OPEN CLOSE |
| size | string | Quantity of the order |
| price | string | Price of the order ※It is returned if status is LIMIT or STOP . |
| status | string | Order Status: WAITING ORDERED MODIFYING CANCELED EXECUTED EXPIRED |
| cancelType | string | Cancel Type: USER INSUFFICIENT_COLLATERAL INSUFFICIENT_MARGIN SPEED OCO EXPIRATION PRICE_BOUND OUT_OF_SLIPPAGE_RANGE ※It is returned if status is CANCELED, or EXPIRED. |
| expiry | string | Expiry date |
| timestamp | string | Ordered timestamp |
Active Orders
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'GET';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/activeOrders';
const parameters = '?symbol=USD_JPY&prevId=123456790&count=10';
const text = timestamp + method + path;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.get(endPoint + path + parameters, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/activeOrders'
text = timestamp + method + path
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
parameters = {
"symbol": "USD_JPY",
"prevId": 123456790,
"count": 10
}
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.get(endPoint + path, headers=headers, params=parameters)
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "GET"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/activeOrders"
parameters := "?symbol=USD_JPY&prevId=123456790&count=10"
text := timestamp + method + path
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path+parameters, nil)
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/activeOrders'
parameters = {
:symbol => 'USD_JPY',
:prevId => 123456790,
:count => 10
}
text = timestamp + method + path
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
uri.query = URI.encode_www_form(parameters)
req = Net::HTTP::Get.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "GET"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/activeOrders"
var parameters = "?symbol=USD_JPY&prevId=123456790&count=10"
var text = timestamp + method + path
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path + parameters)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'GET';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/activeOrders';
$parameters = '?symbol=USD_JPY&prevId=123456790&count=10';
$text = $timestamp . $method . $path;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path . $parameters);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$headers = array(
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
active_orders().unwrap();
}
fn active_orders() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "GET";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/activeOrders";
let parameters = json!({
"symbol": "USD_JPY",
"prevId": 123456790,
"count": 10
});
let text = format!("{}{}{}", timestamp, method, path);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.get(&(endpoint.to_string() + path))
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.query(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "GET"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/activeOrders"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "GET"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestQueryString [("symbol", Just "USD_JPY"), ("prevId", Just "123456790"), ("count", Just "10")]
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = ActiveOrders();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> ActiveOrders()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "GET";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/activeOrders";
const string parameters = "?symbol=USD_JPY&prevId=123456790&count=10";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path + parameters))
{
var text = timestamp + method + path;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "GET"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/activeOrders"
let parameters = "?symbol=USD_JPY&prevId=123456790&count=10"
let text = timestamp + method + path
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path + parameters)!)
request.httpMethod = method
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": {
"list": [
{
"rootOrderId": 123456789,
"orderId": 123456789,
"clientOrderId": "abc123",
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "NORMAL",
"executionType": "LIMIT",
"settleType": "OPEN",
"size": "10000",
"price": "135.5",
"status": "ORDERED",
"expiry": "20190418",
"timestamp": "2019-03-19T01:07:24.217Z"
}
]
},
"responsetime": "2019-03-19T01:07:24.217Z"
}
Gets active orders list of the specified symbol.
Request
GET /private/v1/activeOrders
Parameters
- Parameter type: query
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| symbol | string | Optional | The handling symbols are here |
| prevId | number | Optional | Order ID specify※ If not specified, gets from the latest data. If specified, gets data with Order ID smaller than the specified value. |
| count | number | Optional | Number of items: If a count is not specified, it will run assuming 100 (maximum value) is set. |
Response
| Property Name | Value | Description |
|---|---|---|
| rootOrderId | number | Root order id |
| orderId | number | Order id |
| clientOrderId | string | Client order id ※Returned only when set |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| orderType | string | Order Type: NORMAL OCO IFD IFDOCO |
| executionType | string | Execution Type: LIMIT STOP |
| settleType | string | Settlement Type: OPEN CLOSE |
| size | string | Quantity of the order |
| price | string | Price of the order |
| status | string | Order Status: WAITING MODIFYING ORDERED |
| expiry | string | Expiry date |
| timestamp | string | Ordered timestamp |
Executions
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'GET';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/executions';
const parameters = '?executionId=72123911,92123912';
const text = timestamp + method + path;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.get(endPoint + path + parameters, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/executions'
text = timestamp + method + path
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
parameters = {
"executionId": "72123911,92123912"
}
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.get(endPoint + path, headers=headers, params=parameters)
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "GET"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/executions"
parameters := "?executionId=72123911,92123912"
text := timestamp + method + path
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path+parameters, nil)
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/executions'
parameters = {
:executionId => '72123911,92123912'
}
text = timestamp + method + path
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
uri.query = URI.encode_www_form(parameters)
req = Net::HTTP::Get.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "GET"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/executions"
var parameters = "?executionId=72123911,92123912"
var text = timestamp + method + path
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path + parameters)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'GET';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/executions';
$parameters = '?executionId=72123911,92123912';
$text = $timestamp . $method . $path;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path . $parameters);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$headers = array(
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use std::collections::HashMap;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
executions().unwrap();
}
fn executions() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "GET";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/executions";
let mut parameters = HashMap::new();
parameters.insert("executionId", "72123911,92123912");
let text = format!("{}{}{}", timestamp, method, path);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.get(&(endpoint.to_string() + path))
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.query(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "GET"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/executions"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "GET"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestQueryString [("executionId", Just "72123911,92123912")]
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = Executions();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> Executions()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "GET";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/executions";
const string parameters = "?executionId=72123911,92123912";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path + parameters))
{
var text = timestamp + method + path;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "GET"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/executions"
let parameters = "?executionId=72123911,92123912"
let text = timestamp + method + path
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path + parameters)!)
request.httpMethod = method
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": {
"list": [
{
"amount":"16215.999",
"executionId": 92123912,
"clientOrderId": "aaaaa",
"orderId": 223456789,
"positionId": 2234567,
"symbol": "USD_JPY",
"side": "SELL",
"settleType": "CLOSE",
"size": "10000",
"price": "141.251",
"lossGain": "15730",
"fee": "-30",
"settledSwap":"515.999",
"timestamp": "2020-11-24T21:27:04.764Z"
},
{
"amount":"0",
"executionId": 72123911,
"clientOrderId": "bbbbb",
"orderId": 123456789,
"positionId": 1234567,
"symbol": "USD_JPY",
"side": "BUY",
"settleType": "OPEN",
"size": "10000",
"price": "141.269",
"lossGain": "0",
"fee": "0",
"settledSwap":"0",
"timestamp": "2020-11-24T19:47:51.234Z"
}
]
},
"responsetime": "2019-03-19T02:15:06.081Z"
}
Gets executed order information of the specified order id or execution id.
- One of
orderIdexecutionIdis required. Both cannot be set at the same time.
Request
GET /private/v1/executions
Parameters
- Parameter type: query
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| orderId | number | * |
Either orderId or executionId is required. |
| executionId | string | * |
Either orderId or executionId is required.※ executionId can be up to 10, separated by commas. |
Response
| Property Name | Value | Description |
|---|---|---|
| amount | string | Delivery amount |
| executionId | number | Execution id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| positionId | number | Position id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| settleType | string | Settlement Type: OPEN CLOSE |
| size | string | Executed quantity |
| price | string | Executed price |
| lossGain | string | Settlement profit/loss |
| fee | string | Trade fee |
| settledSwap | string | Settled swap |
| timestamp | string | Executed timestamp |
Latest Executions
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'GET';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/latestExecutions';
const parameters = '?symbol=USD_JPY&count=100';
const text = timestamp + method + path;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.get(endPoint + path + parameters,, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/latestExecutions'
text = timestamp + method + path
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
parameters = {
"symbol": "USD_JPY",
"count": 100
}
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.get(endPoint + path, headers=headers, params=parameters)
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "GET"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/latestExecutions"
parameters := "?symbol=USD_JPY&count=100"
text := timestamp + method + path
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path+parameters, nil)
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/latestExecutions'
parameters = {
:symbol => 'USD_JPY',
:count => 100
}
text = timestamp + method + path
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
uri.query = URI.encode_www_form(parameters)
req = Net::HTTP::Get.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "GET"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/latestExecutions"
var parameters = "?symbol=USD_JPY&count=100"
var text = timestamp + method + path
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path + parameters)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'GET';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/latestExecutions';
$parameters = '?symbol=USD_JPY&count=100';
$text = $timestamp . $method . $path;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path . $parameters);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$headers = array(
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
latest_executions().unwrap();
}
fn latest_executions() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "GET";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/latestExecutions";
let parameters = json!({
"symbol": "USD_JPY",
"count": 100,
});
let text = format!("{}{}{}", timestamp, method, path);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.get(&(endpoint.to_string() + path))
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.query(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "GET"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/latestExecutions"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "GET"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestQueryString [("symbol", Just "USD_JPY"), ("count", Just "100")]
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = LatestExecutions();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> LatestExecutions()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "GET";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/latestExecutions";
const string parameters = "?symbol=USD_JPY&count=100";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path + parameters))
{
var text = timestamp + method + path;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "GET"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/latestExecutions"
let parameters = "?symbol=USD_JPY&count=100"
let text = timestamp + method + path
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path + parameters)!)
request.httpMethod = method
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": {
"list": [
{
"amount":"16215.999",
"executionId": 92123912,
"clientOrderId": "ccccc",
"orderId": 223456789,
"positionId": 2234567,
"symbol": "USD_JPY",
"side": "SELL",
"settleType": "CLOSE",
"size": "10000",
"price": "141.251",
"lossGain": "15730",
"fee": "-30",
"settledSwap":"515.999",
"timestamp": "2020-11-24T21:27:04.764Z"
}
]
},
"responsetime": "2019-03-19T02:15:06.086Z"
}
Gets the latest executed order information.
- Returns the latest 100 contract executed order information from the past day.
Request
GET /private/v1/latestExecutions
Parameters
- Parameter type: query
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| symbol | string | Required |
The handling symbols are here |
| count | number | Optional | Number of items: If a count is not specified, it will run assuming 100 (maximum value) is set. |
Response
| Property Name | Value | Description |
|---|---|---|
| amount | string | Delivery amount |
| executionId | number | Execution id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| positionId | number | Position id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| settleType | string | Settlement Type: OPEN CLOSE |
| size | string | Executed quantity |
| price | string | Executed price |
| lossGain | string | Settlement profit/loss |
| fee | string | Trade fee |
| settledSwap | string | Settled swap |
| timestamp | string | Executed timestamp |
Open Positions
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'GET';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/openPositions';
const parameters = '?symbol=USD_JPY&prevId=123456790&count=100';
const text = timestamp + method + path;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.get(endPoint + path + parameters, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/openPositions'
text = timestamp + method + path
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
parameters = {
"symbol": "USD_JPY",
"prevId": 123456790,
"count": 100
}
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.get(endPoint + path, headers=headers, params=parameters)
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "GET"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/openPositions"
parameters := "?symbol=USD_JPY&prevId=123456790&count=100"
text := timestamp + method + path
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path+parameters, nil)
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/openPositions'
parameters = {
:symbol => 'USD_JPY',
:prevId => 123456790,
:count => 100
}
text = timestamp + method + path
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
uri.query = URI.encode_www_form(parameters)
req = Net::HTTP::Get.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "GET"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/openPositions"
var parameters = "?symbol=USD_JPY&prevId=123456790&count=100"
var text = timestamp + method + path
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path + parameters)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'GET';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/openPositions';
$parameters = '?symbol=USD_JPY&prevId=123456790&count=100';
$text = $timestamp . $method . $path;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path . $parameters);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$headers = array(
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
open_positions().unwrap();
}
fn open_positions() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "GET";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/openPositions";
let parameters = json!({
"symbol": "USD_JPY",
"prevId": 123456790,
"count": 100,
});
let text = format!("{}{}{}", timestamp, method, path);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.get(&(endpoint.to_string() + path))
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.query(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "GET"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/openPositions"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "GET"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestQueryString [("symbol", Just "USD_JPY"), ("prevId", Just "123456790"), ("count", Just "100")]
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = OpenPositions();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> OpenPositions()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "GET";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/openPositions";
const string parameters = "?symbol=USD_JPY&prevId=123456790&count=100";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path + parameters))
{
var text = timestamp + method + path;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "GET"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/openPositions"
let parameters = "?symbol=USD_JPY&prevId=123456790&count=100"
let text = timestamp + method + path
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path + parameters)!)
request.httpMethod = method
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": {
"list": [
{
"positionId": 123456789,
"symbol": "USD_JPY",
"side": "BUY",
"size": "10000",
"orderedSize": "0",
"price": "141.269",
"lossGain": "-1980",
"totalSwap":"0" ,
"timestamp": "2019-03-21T05:18:09.011Z"
}
]
},
"responsetime": "2019-03-19T02:15:06.095Z"
}
Gets a list of opened postions.
Request
GET /private/v1/openPositions
Parameters
- Parameter type: query
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| symbol | string | Optional | The handling symbols are here |
| prevId | number | Optional | Position ID specify※ If not specified, gets from the latest data. If specified, gets data with Position ID smaller than the specified value. |
| count | number | Optional | Number of items: If a count is not specified, it will run assuming 100 (maximum value) is set. |
Response
| Property Name | Value | Description |
|---|---|---|
| positionId | number | Position id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| size | string | Quantity of the position |
| orderedSize | string | Quantity of the order |
| price | string | Price of the position |
| lossGain | string | Settlement profit/loss |
| totalSwap | string | Total swap |
| timestamp | string | Executed timestamp |
Position Summary
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'GET';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/positionSummary';
const parameters = '?symbol=USD_JPY';
const text = timestamp + method + path;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.get(endPoint + path + parameters, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/positionSummary'
text = timestamp + method + path
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
parameters = {
"symbol": "USD_JPY"
}
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.get(endPoint + path, headers=headers, params=parameters)
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "GET"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/positionSummary"
parameters := "?symbol=USD_JPY"
text := timestamp + method + path
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path+parameters, nil)
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'GET'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/positionSummary'
parameters = {
:symbol => 'USD_JPY'
}
text = timestamp + method + path
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
uri.query = URI.encode_www_form(parameters)
req = Net::HTTP::Get.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "GET"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/positionSummary"
var parameters = "?symbol=USD_JPY"
var text = timestamp + method + path
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path + parameters)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'GET';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/positionSummary';
$parameters = '?symbol=USD_JPY';
$text = $timestamp . $method . $path;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path . $parameters);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$headers = array(
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use std::collections::HashMap;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
position_summary().unwrap();
}
fn position_summary() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "GET";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/positionSummary";
let mut parameters = HashMap::new();
parameters.insert("symbol", "USD_JPY");
let text = format!("{}{}{}", timestamp, method, path);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.get(&(endpoint.to_string() + path))
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.query(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "GET"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/positionSummary"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "GET"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestQueryString [("symbol", Just "USD_JPY")]
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = PositionSummary();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> PositionSummary()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "GET";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/positionSummary";
const string parameters = "?symbol=USD_JPY";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path + parameters))
{
var text = timestamp + method + path;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "GET"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/positionSummary"
let parameters = "?symbol=USD_JPY"
let text = timestamp + method + path
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path + parameters)!)
request.httpMethod = method
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": {
"list": [
{
"averagePositionRate": "140.043",
"positionLossGain": "2322204.675",
"side": "BUY",
"sumOrderedSize": "0",
"sumPositionSize": "1353339",
"sumTotalSwap": "161600.404",
"symbol": "USD_JPY"
},
{
"averagePositionRate": "140.082",
"positionLossGain": "-2588483.591",
"side": "SELL",
"sumOrderedSize": "20000",
"sumPositionSize": "1481339",
"sumTotalSwap": "-178353.217",
"symbol": "USD_JPY"
}
]
},
"responsetime": "2019-03-19T02:15:06.102Z"
}
Gets a list of the position summary.
- It is possible to get the position summary by symbol and side (BUY/SELL).
- If you want to get the position summary of all symbols, we recommend calling out it without a symbol.
Request
GET /private/v1/positionSummary
Parameters
- Parameter type: query
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| symbol | string | Optional | If a symbol is not specified, it will return the position summary of all symbols. The handling symbols are here |
Response
| Property Name | Value | Description |
|---|---|---|
| averagePositionRate | string | Average price of the position |
| positionLossGain | string | Settlement profit/loss |
| side | string | Side: BUY SELL |
| sumOrderedSize | string | Total quantity of the order |
| sumPositionSize | string | Total quantity of the position |
| sumTotalSwap | string | Total swap |
| symbol | string | The handling symbols are here |
Speed Order
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/speedOrder';
const reqBody = JSON.stringify({
symbol: "USD_JPY",
side: "BUY",
clientOrderId: "abc123",
size: "10000",
upperBound: "138",
isHedgeableze: "false"
})
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/speedOrder'
reqBody = {
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"size": "10000",
"upperBound": "138",
"isHedgeableze": "false"
}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/speedOrder"
reqBody := (`{
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"size": "10000",
"upperBound": "138",
"isHedgeableze": "false"
}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/speedOrder'
reqBody = {
:symbol => 'USD_JPY',
:side => 'BUY',
:clientOrderId => 'abc123',
:size => '10000',
:upperBound => '138',
:isHedgeable => 'false'
}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/speedOrder"
var reqBody = """
{"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"size": "10000",
"upperBound": "138",
"isHedgeable": "false"
}
"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/speedOrder';
$reqBody = '{
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"size": "10000",
"upperBound": "138",
"isHedgeable": "false"
}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
speedOrder().unwrap();
}
fn speedOrder() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/speedOrder";
let parameters = json!({
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"size": "10000",
"upperBound": "138",
"isHedgeable": false
});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/speedOrder"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"size": "10000",
"upperBound": "138",
"isHedgeable": "false"}
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = speedOrder();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> speedOrder()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/speedOrder";
var reqBody = "{ \"symbol\": \"USD_JPY\", " +
"\"side\": \"BUY\", " +
"\"clientOrderId\": \"abc123\", " +
"\"size\": \"10000\", " +
"\"upperBound\": \"138\", " +
"\"isHedgeable\": \"false\"}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/speedOrder"
let reqBodyStr = """
{
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"size": "10000",
"upperBound": "138",
"isHedgeable": "false"
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"rootOrderId": 123456789,
"clientOrderId": "sygngz1234",
"orderId": 123456789,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "NORMAL",
"executionType": "MARKET",
"settleType": "OPEN",
"size": "10000",
"status": "EXECUTED",
"timestamp": "2019-03-19T02:15:06.059Z"
}
],
"responsetime": "2019-03-19T02:15:06.069Z"
}
Creates a new Speed Order
Request
POST /private/v1/speedOrder
Parameters
- Parameter content type:
application/json
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| symbol | string | Required |
The handling symbols are here |
| side | string | Required |
BUY SELL |
| clientOrderId | string | Optional | Client order id ※Only combinations of up to 36 single-byte alphanumeric characters can be used. |
| size | string | Required |
Quantity of the order |
| lowerBound | string | Optional | Maximum price ※Can be specified for side: SELL. |
| upperBound | string | Optional | Minimum price ※Can be specified for side: BUY. |
| isHedgeable | bool | Optional | No double-build: false(default) Double-build:true |
Response
| Property Name | Value | Description |
|---|---|---|
| rootOrderId | number | Root order id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| orderType | string | Order Type: NORMAL |
| executionType | string | Execution Type: MARKET |
| settleType | string | Settlement Type: OPEN CLOSE |
| size | string | Quantity of the order |
| status | string | Order Status: EXECUTED EXPIRED |
| cancelType | string | Cancel Type: PRICE_BOUND ※It is returned if status is EXPIRED. |
| timestamp | string | Ordered timestamp |
Order
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/order';
const reqBody = JSON.stringify({
symbol: "USD_JPY",
side: "BUY",
size: "10000",
clientOrderId: "abc123",
executionType: "LIMIT",
limitPrice: "130"
})
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/order'
reqBody = {
"symbol": "USD_JPY",
"side": "BUY",
"size": "10000",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "130"
}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/order"
reqBody := (`{
"symbol": "USD_JPY",
"side": "BUY",
"size": "10000",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "130"
}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/order'
reqBody = {
:symbol => 'USD_JPY',
:side => 'BUY',
:size => '10000',
:clientOrderId => 'abc123',
:executionType => 'LIMIT',
:limitPrice => '130'
}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/order"
var reqBody = """
{"symbol": "USD_JPY",
"side": "BUY",
"size": "10000",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "130"
}
"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/order';
$reqBody = '{
"symbol": "USD_JPY",
"side": "BUY",
"size": "10000",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "130"
}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
order().unwrap();
}
fn order() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/order";
let parameters = json!({
"symbol": "USD_JPY",
"side": "BUY",
"size": "10000",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "130"
});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/order"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"symbol": "USD_JPY",
"side": "BUY",
"size": "10000",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "130" }
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = Order();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> Order()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/order";
var reqBody = "{ \"symbol\": \"USD_JPY\", " +
"\"side\": \"BUY\", " +
"\"size\": \"10000\", " +
"\"clientOrderId\": \"abc123\", " +
"\"executionType\": \"LIMIT\", " +
"\"limitPrice\": \"130\"}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/order"
let reqBodyStr = """
{
"symbol": "USD_JPY",
"side": "BUY",
"size": "10000",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "130"
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456789,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "NORMAL",
"executionType": "LIMIT",
"settleType": "OPEN",
"size": "10000",
"price": "130",
"status": "WAITING",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
}
],
"responsetime": "2019-03-19T02:15:06.059Z"
}
Creates a new order
Request
POST /private/v1/order
Parameters
- Parameter content type:
application/json
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| symbol | string | Required |
The handling symbols are here |
| side | string | Required |
BUY SELL |
| size | string | Required |
Quantity of the order |
| clientOrderId | string | Optional | Client order id ※Only combinations of up to 36 single-byte alphanumeric characters can be used. |
| executionType | string | Required |
MARKET LIMIT STOP OCO |
| limitPrice | string | *Depending on executionType |
Limit order rate ※Required if LIMIT OCO . Not required if |
| stopPrice | string | *Depending on executionType |
Stop order rate ※Required if STOP OCO. Not required if |
| lowerBound | string | Optional | Maximum price ※Can be specified for executionType: MARKET side: SELL. |
| upperBound | string | Optional | Minimum price ※Can be specified for executionType: MARKET side:BUY. |
Response
| Property Name | Value | Description |
|---|---|---|
| rootOrderId | number | Root order id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| orderType | string | Order Type: NORMAL OCO |
| executionType | string | Execution Type: MARKET LIMIT STOP |
| settleType | string | Settlement Type: OPEN |
| size | string | Quantity of the order |
| price | string | Price of the order ※It is returned if status is LIMIT or STOP. |
| status | string | Order Status: WAITING EXECUTED EXPIRED |
| cancelType | string | Cancel Type: PRICE_BOUND OCO ※It is returned if status is EXPIRED. |
| expiry | string | Expiry date |
| timestamp | string | Ordered timestamp |
Ifd Order
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/ifdOrder';
const reqBody = JSON.stringify({
symbol: "USD_JPY",
clientOrderId: "abc123",
firstSide: "BUY",
firstExecutionType: "LIMIT",
firstSize: "10000",
firstPrice: "130",
secondExecutionType: "LIMIT",
secondSize: "10000",
secondPrice: "145"
})
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/ifdOrder'
reqBody = {
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "130",
"secondExecutionType": "LIMIT",
"secondSize": "10000",
"secondPrice": "145"
}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/ifdOrder"
reqBody := (`{
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "130",
"secondExecutionType": "LIMIT",
"secondSize": "10000",
"secondPrice": "145"
}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/ifdOrder'
reqBody = {
:symbol => 'USD_JPY',
:clientOrderId => 'abc123',
:firstSide => 'BUY',
:firstExecutionType => 'LIMIT',
:firstSize => '10000',
:firstPrice => '130',
:secondExecutionType => 'LIMIT',
:secondSize => '10000',
:secondPrice => '145'
}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/ifdOrder"
var reqBody = """
{"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "130",
"secondExecutionType": "LIMIT",
"secondSize": "10000",
"secondPrice": "145"
}
"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/ifdOrder';
$reqBody = '{
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "130",
"secondExecutionType": "LIMIT",
"secondSize": "10000",
"secondPrice": "145"
}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
order().unwrap();
}
fn order() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/ifdOrder";
let parameters = json!({
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "130",
"secondExecutionType": "LIMIT",
"secondSize": "10000",
"secondPrice": "145"
});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/ifdOrder"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "130",
"secondExecutionType": "LIMIT",
"secondSize": "10000",
"secondPrice": "145"}
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = Order();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> Order()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/ifdOrder";
var reqBody = "{ \"symbol\": \"USD_JPY\", " +
"\"clientOrderId\": \"abc123\", " +
"\"firstSide\": \"BUY\", " +
"\"firstExecutionType\": \"LIMIT\", " +
"\"firstSize\": \"10000\", " +
"\"firstPrice\": \"130\", " +
"\"secondExecutionType\": \"LIMIT\", " +
"\"secondSize\": \"10000\", " +
"\"secondPrice\": \"145\"}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/ifdOrder"
let reqBodyStr = """
{
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "130",
"secondExecutionType": "LIMIT",
"secondSize": "10000",
"secondPrice": "145"
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456789,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "IFD",
"executionType": "LIMIT",
"settleType": "OPEN",
"size": "10000",
"price": "130",
"status": "WAITING",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
},
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456790,
"symbol": "USD_JPY",
"side": "SELL",
"orderType": "IFD",
"executionType": "LIMIT",
"settleType": "CLOSE",
"size": "10000",
"price": "145",
"status": "WAITING",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
}
],
"responsetime": "2019-03-19T02:15:06.059Z"
}
Creates a new ifd order
Request
POST /private/v1/ifdOrder
Parameters
- Parameter content type:
application/json
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| symbol | string | Required |
The handling symbols are here |
| clientOrderId | string | Optional | Client order id ※Only combinations of up to 36 single-byte alphanumeric characters can be used. |
| firstSide | string | Required |
BUY SELL※The side not specified in firstSide becomes the side of the second order. |
| firstExecutionType | string | Required |
LIMIT STOP |
| firstSize | string | Required |
Quantity of the first order |
| firstPrice | string | Required |
First order rate |
| secondExecutionType | string | Required |
LIMIT STOP |
| secondSize | string | Required |
Quantity of the second order |
| secondPrice | string | Required |
Second order rate |
Response
| Property Name | Value | Description |
|---|---|---|
| rootOrderId | number | Root order id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| orderType | string | Order Type: IFD |
| executionType | string | Execution Type: LIMIT STOP |
| settleType | string | Settlement Type: OPEN CLOSE |
| size | string | Quantity of the order |
| price | string | Price of the order |
| status | string | Order Status: WAITING ORDERED EXECUTED |
| expiry | string | Expiry date |
| timestamp | string | Ordered timestamp |
Ifdoco Order
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/ifoOrder';
const reqBody = JSON.stringify({
symbol: "USD_JPY",
clientOrderId: "abc123",
firstSide: "BUY",
firstExecutionType: "LIMIT",
firstSize: "10000",
firstPrice: "135",
secondSize: "10000",
secondLimitPrice: "140",
secondStopPrice: "132"
})
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/ifoOrder'
reqBody = {
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "135",
"secondSize": "10000",
"secondLimitPrice": "140",
"secondStopPrice": "132"
}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/ifoOrder"
reqBody := (`{
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "135",
"secondSize": "10000",
"secondLimitPrice": "140",
"secondStopPrice": "145"
}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/ifoOrder'
reqBody = {
:symbol => 'USD_JPY',
:clientOrderId => 'abc123',
:firstSide => 'BUY',
:firstExecutionType => 'LIMIT',
:firstSize => '10000',
:firstPrice => '135',
:secondSize => '10000',
:secondLimitPrice => '140',
:secondStopPrice => '132'
}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/ifoOrder"
var reqBody = """
{"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "135",
"secondSize": "10000",
"secondLimitPrice": "140",
"secondStopPrice": "132"
}
"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/ifoOrder';
$reqBody = '{
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "135",
"secondSize": "10000",
"secondLimitPrice": "140",
"secondStopPrice": "132"
}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
order().unwrap();
}
fn order() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/ifoOrder";
let parameters = json!({
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "135",
"secondSize": "10000",
"secondLimitPrice": "140",
"secondStopPrice": "132"
});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/ifoOrder"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "135",
"secondSize": "10000",
"secondLimitPrice": "140",
"secondStopPrice": "132"}
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = Order();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> Order()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/ifoOrder";
var reqBody = "{ \"symbol\": \"USD_JPY\", " +
"\"clientOrderId\": \"abc123\", " +
"\"firstSide\": \"BUY\", " +
"\"firstExecutionType\": \"LIMIT\", " +
"\"firstSize\": \"10000\", " +
"\"firstPrice\": \"135\", " +
"\"secondSize\": \"10000\", " +
"\"secondLimitPrice\": \"140\", " +
"\"secondStopPrice\": \"132\"}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/ifoOrder"
let reqBodyStr = """
{
"symbol": "USD_JPY",
"clientOrderId": "abc123",
"firstSide": "BUY",
"firstExecutionType": "LIMIT",
"firstSize": "10000",
"firstPrice": "135",
"secondSize": "10000",
"secondLimitPrice": "140",
"secondStopPrice": "132"
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456789,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "IFDOCO",
"executionType": "LIMIT",
"settleType": "OPEN",
"size": "10000",
"price": "135",
"status": "WAITING",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
},
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456790,
"symbol": "USD_JPY",
"side": "SELL",
"orderType": "IFDOCO",
"executionType": "LIMIT",
"settleType": "CLOSE",
"size": "10000",
"price": "140",
"status": "WAITING",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
},
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456791,
"symbol": "USD_JPY",
"side": "SELL",
"orderType": "IFDOCO",
"executionType": "STOP",
"settleType": "CLOSE",
"size": "10000",
"price": "132",
"status": "WAITING",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
}
],
"responsetime": "2019-03-19T02:15:06.059Z"
}
Creates a new ifdoco order
Request
POST /private/v1/ifoOrder
Parameters
- Parameter content type:
application/json
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| symbol | string | Required |
The handling symbols are here |
| clientOrderId | string | Optional | Client order id ※Only combinations of up to 36 single-byte alphanumeric characters can be used. |
| firstSide | string | Required |
BUY SELL※The side not specified in firstSide becomes the side of the second order. |
| firstExecutionType | string | Required |
LIMIT STOP |
| firstSize | string | Required |
Quantity of the first order |
| firstPrice | string | Required |
First order rate |
| secondSize | string | Required |
Quantity of the second order |
| secondLimitPrice | string | Required |
Second limit order rate |
| secondStopPrice | string | Required |
Second stop order rate |
Response
| Property Name | Value | Description |
|---|---|---|
| rootOrderId | number | Root order id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| orderType | string | Order Type: IFDOCO |
| executionType | string | Execution Type: LIMIT STOP |
| settleType | string | Settlement Type: OPEN CLOSE |
| size | string | Quantity of the order |
| price | string | Price of the order |
| status | string | Order Status: WAITING ORDERED EXECUTED |
| expiry | string | Expiry date |
| timestamp | string | Ordered timestamp |
Change Order
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/changeOrder';
const reqBody = JSON.stringify({
orderId: 123456789,
price: "139"
})
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/changeOrder'
reqBody = {
"orderId": 123456789,
"price": "139"
}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/changeOrder"
reqBody := (`{
"orderId": 123456789,
"price": "139"
}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/changeOrder'
reqBody = {
:orderId => 123456789,
:price => '139'
}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/changeOrder"
var reqBody = """
{"orderId": 123456789, "price": "139"}
"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/changeOrder';
$reqBody = '{
orderId: 123456789,
price: "139"
}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
change_order().unwrap();
}
fn change_order() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/changeOrder";
let parameters = json!({
"orderId": 123456789,
"price": "139"
});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/changeOrder"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"orderId": 123456789,
"price": "139"
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = ChangeOrder();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> ChangeOrder()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/changeOrder";
var reqBody = "{ \"orderId\": 123456789, " +
"\"price\": \"139\"}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/changeOrder"
let reqBodyStr = """
{
"orderId": 123456789,
"price": "139"
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456789,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "NORMAL",
"executionType": "LIMIT",
"settleType": "OPEN",
"size": "10000",
"price": "139",
"status": "ORDERED",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
}
],
"responsetime": "2019-03-19T02:15:06.059Z"
}
Changes an order.
- One of
orderIdclientOrderIdis required. Both cannot be set at the same time.
Request
POST /private/v1/changeOrder
Parameters
- Parameter content type:
application/json
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| orderId | number | * |
Either orderId or clientOrderId is required. |
| clientOrderId | string | * |
Either orderId or clientOrderId is required. |
| price | string | Required |
Order rate |
Response
| Property Name | Value | Description |
|---|---|---|
| rootOrderId | number | Root order id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| orderType | string | Order Type: NORMAL |
| executionType | string | Execution Type: LIMIT STOP |
| settleType | string | Settlement Type: OPEN CLOSE |
| size | string | Quantity of the order |
| price | string | Price of the order |
| status | string | Order Status: ORDERED MODIFYING EXECUTED |
| expiry | string | Expiry date |
| timestamp | string | Ordered timestamp |
Change Oco Order
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/changeOcoOrder';
const reqBody = JSON.stringify({
"clientOrderId": "abc123",
"limitPrice": "140.525",
"stopPrice": "145.607"
})
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/changeOcoOrder'
reqBody = {
"clientOrderId": "abc123",
"limitPrice": "140.525",
"stopPrice": "145.607"
}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/changeOcoOrder"
reqBody := (`{
"clientOrderId": "abc123",
"limitPrice": "140.525",
"stopPrice": "145.607"
}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/changeOcoOrder'
reqBody = {
:clientOrderId => 'abc123',
:limitPrice => '140.525',
:stopPrice => '145.607'
}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/changeOcoOrder"
var reqBody = """
{"clientOrderId": "abc123", "limitPrice": "140.525", "stopPrice": "145.607"}
"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/changeOcoOrder';
$reqBody = '{
clientOrderId: "abc123",
limitPrice: "140.525",
stopPrice: "145.607"
}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
change_order().unwrap();
}
fn change_order() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/changeOcoOrder";
let parameters = json!({
"clientOrderId": "abc123",
"limitPrice": "140.525",
"stopPrice": "145.607"
});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/changeOcoOrder"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"clientOrderId": "abc123",
"limitPrice": "140.525",
"stopPrice": "145.607"
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = ChangeOrder();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> ChangeOrder()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/changeOcoOrder";
var reqBody = "{ \"clientOrderId\": \"abc123\", " +
"\"limitPrice\": \"140.525\", " +
"\"stopPrice\": \"145.607\"}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/changeOcoOrder"
let reqBodyStr = """
{
"clientOrderId": "abc123",
"limitPrice": "140.525",
"stopPrice": "145.607"
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456789,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "OCO",
"executionType": "LIMIT",
"settleType": "OPEN",
"size": "10000",
"price": "140.525",
"status": "EXECUTED",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
},
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456790,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "OCO",
"executionType": "STOP",
"settleType": "OPEN",
"size": "10000",
"price": "145.607",
"status": "EXPIRED",
"cancelType": "OCO",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
}
],
"responsetime": "2019-03-19T02:15:06.059Z"
}
Changes an Oco order.
- One of
rootOrderIdclientOrderIdis required. Both cannot be set at the same time. - Either
limitPriceorstopPriceor both required.
Request
POST /private/v1/changeOcoOrder
Parameters
- Parameter content type:
application/json
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| rootOrderId | number | * |
Either rootOrderId or clientOrderId is required. |
| clientOrderId | string | * |
Either rootOrderId or clientOrderId is required. |
| limitPrice | string | * |
Limit order rate ※ Either limitPrice or stopPrice or both required. |
| stopPrice | string | * |
Stop order rate ※ Either limitPrice or stopPrice or both required. |
Response
| Property Name | Value | Description |
|---|---|---|
| rootOrderId | number | Root order id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| orderType | string | Order Type: OCO |
| executionType | string | Execution Type: LIMIT STOP |
| settleType | string | Settlement Type: OPEN CLOSE |
| size | string | Quantity of the order |
| price | string | Price of the order |
| status | string | Order Status: ORDERED MODIFYING EXECUTED EXPIRED |
| cancelType | string | Cancel Type: OCO ※It is returned if status is EXPIRED. |
| expiry | string | Expiry date |
| timestamp | string | Ordered timestamp |
Change Ifd Order
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/changeIfdOrder';
const reqBody = JSON.stringify({
"rootOrderId": 123456789,
"firstPrice": "136.201",
"secondPrice": "139.802"
})
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/changeIfdOrder'
reqBody = {
"rootOrderId": 123456789,
"firstPrice": "136.201",
"secondPrice": "139.802"
}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/changeIfdOrder"
reqBody := (`{
"rootOrderId": 123456789,
"firstPrice": "136.201",
"secondPrice": "139.802"
}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/changeIfdOrder'
reqBody = {
:rootOrderId => 123456789,
:firstPrice => '136.201',
:secondPrice => '139.802'
}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/changeIfdOrder"
var reqBody = """
{"rootOrderId": 123456789, "firstPrice": "136.201", "secondPrice": "139.802"}
"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/changeIfdOrder';
$reqBody = '{
rootOrderId": 123456789,
firstPrice": "136.201",
secondPrice": "139.802"
}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
change_order().unwrap();
}
fn change_order() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/changeIfdOrder";
let parameters = json!({
"rootOrderId": 123456789,
"firstPrice": "136.201",
"secondPrice": "139.802"
});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/changeIfdOrder"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"rootOrderId": 123456789,
"firstPrice": "136.201",
"secondPrice": "139.802"
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = ChangeOrder();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> ChangeOrder()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/changeIfdOrder";
var reqBody = "{ \"rootOrderId\": 123456789, " +
"\"firstPrice\": \"136.201\", " +
"\"secondPrice\": \"139.802\"}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/changeIfdOrder"
let reqBodyStr = """
{
"rootOrderId": 123456789,
"firstPrice": "136.201",
"secondPrice": "139.802"
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456789,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "IFD",
"executionType": "LIMIT",
"settleType": "OPEN",
"size": "10000",
"price": "136.201",
"status": "ORDERED",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
},
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456790,
"symbol": "USD_JPY",
"side": "SELL",
"orderType": "IFD",
"executionType": "LIMIT",
"settleType": "CLOSE",
"size": "10000",
"price": "139.802",
"status": "WAITING",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
}
],
"responsetime": "2019-03-19T02:15:06.059Z"
}
Changes a Ifd order.
- One of
rootOrderIdclientOrderIdis required. Both cannot be set at the same time. - Either
firstPriceorsecondPriceor both required.
Request
POST /private/v1/changeIfdOrder
Parameters
- Parameter content type:
application/json
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| rootOrderId | number | * |
Either rootOrderId or clientOrderId is required. |
| clientOrderId | string | * |
Either rootOrderId or clientOrderId is required. |
| firstPrice | string | * |
First order rate ※ Either firstPrice or secondPrice or both required. |
| secondPrice | string | * |
Second limit order rate ※ Either firstPrice or secondPrice or both required. |
Response
| Property Name | Value | Description |
|---|---|---|
| rootOrderId | number | Root order id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| orderType | string | Order Type: IFD |
| executionType | string | Execution Type: LIMIT STOP |
| settleType | string | Settlement Type: OPEN CLOSE |
| size | string | Quantity of the order |
| price | string | Price of the order |
| status | string | Order Status: WAITING ORDERED MODIFYING EXECUTED |
| expiry | string | Expiry date |
| timestamp | string | Ordered timestamp |
Change Ifdoco Order
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/changeIfoOrder';
const reqBody = JSON.stringify({
"clientOrderId": "abc123",
"firstPrice": "142.3",
"secondLimitPrice": "136",
"secondStopPrice": "143.1"
})
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/changeIfoOrder'
reqBody = {
"clientOrderId": "abc123",
"firstPrice": "142.3",
"secondLimitPrice": "136",
"secondStopPrice": "143.1"
}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/changeIfoOrder"
reqBody := (`{
"clientOrderId": "abc123",
"firstPrice": "142.3",
"secondLimitPrice": "136",
"secondStopPrice": "143.1"
}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/changeIfoOrder'
reqBody = {
:clientOrderId => 'abc123',
:firstPrice => '142.3',
:secondStopPrice => '136',
:stopPrice => '143.1'
}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/changeIfoOrder"
var reqBody = """
{"clientOrderId": "abc123", "firstPrice": "142.3", "secondLimitPrice": "136", "secondStopPrice": "143.1"}
"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/changeIfoOrder';
$reqBody = '{
clientOrderId: "abc123",
firstPrice: "142.3",
secondLimitPrice: "136",
secondStopPrice: "143.1"
}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
change_order().unwrap();
}
fn change_order() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/changeIfoOrder";
let parameters = json!({
"clientOrderId": "abc123",
"firstPrice": "142.3",
"secondLimitPrice": "136",
"secondStopPrice": "143.1"
});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/changeIfoOrder"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"clientOrderId": "abc123",
"firstPrice": "142.3",
"secondLimitPrice": "136",
"secondStopPrice": "143.1"
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = ChangeOrder();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> ChangeOrder()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/changeIfoOrder";
var reqBody = "{ \"clientOrderId\": \"abc123\", " +
"\"firstPrice\": \"142.3\", " +
"\"secondLimitPrice\": \"136\", " +
"\"secondStopPrice\": \"143.1\"}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/changeIfoOrder"
let reqBodyStr = """
{
"clientOrderId": "abc123",
"firstPrice": "142.3",
"secondLimitPrice": "136",
"secondStopPrice": "143.1"
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456789,
"symbol": "USD_JPY",
"side": "SELL",
"orderType": "IFDOCO",
"executionType": "LIMIT",
"settleType": "OPEN",
"size": "10000",
"price": "142.3",
"status": "ORDERED",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
},
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456790,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "IFDOCO",
"executionType": "LIMIT",
"settleType": "CLOSE",
"size": "10000",
"price": "136",
"status": "WAITING",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
},
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456791,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "IFDOCO",
"executionType": "STOP",
"settleType": "CLOSE",
"size": "10000",
"price": "143.1",
"status": "WAITING",
"expiry" : "20190418",
"timestamp": "2019-03-19T02:15:06.059Z"
}
],
"responsetime": "2019-03-19T02:15:06.059Z"
}
Changes a Ifdoco order.
- One of
rootOrderIdclientOrderIdis required. Both cannot be set at the same time. - Either or all of
firstPriceorsecondLimitPriceorsecondStopPriceis required.
Request
POST /private/v1/changeIfoOrder
Parameters
- Parameter content type:
application/json
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| rootOrderId | number | * |
Either rootOrderId or clientOrderId is required. |
| clientOrderId | string | * |
Either rootOrderId or clientOrderId is required. |
| firstPrice | string | * |
First order rate ※ Either or all of firstPrice or secondLimitPrice or secondStopPrice is required. |
| secondLimitPrice | string | * |
Second limit order rate ※ Either or all of firstPrice or secondLimitPrice or secondStopPrice is required. |
| secondStopPrice | string | * |
Second stop order rate ※ Either or all of firstPrice or secondLimitPrice or secondStopPrice is required. |
Response
| Property Name | Value | Description |
|---|---|---|
| rootOrderId | number | Root order id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| orderType | string | Order Type: IFDOCO |
| executionType | string | Execution Type: LIMIT STOP |
| settleType | string | Settlement Type: OPEN CLOSE |
| size | string | Quantity of the order |
| price | string | Price of the order |
| status | string | Order Status: WAITING ORDERED MODIFYING EXECUTED EXPIRED |
| cancelType | string | Cancel Type: OCO ※It is returned if status is EXPIRED. |
| expiry | string | Expiry date |
| timestamp | string | Ordered timestamp |
Cancel Orders
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/cancelOrders';
const reqBody = JSON.stringify({
rootOrderIds: [123456789,223456789]
})
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/cancelOrders'
reqBody = {
"rootOrderIds": [123456789,223456789]
}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/cancelOrders"
reqBody := (`{
"rootOrderIds": [123456789,223456789]
}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/cancelOrders'
reqBody = {
:rootOrderIds => [123456789,223456789]
}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/cancelOrders"
var reqBody = """
{"rootOrderIds": [123456789,223456789]}
"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/cancelOrders';
$reqBody = '{
"rootOrderIds": [123456789,223456789]
}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
cancel_orders().unwrap();
}
fn cancel_orders() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/cancelOrders";
let parameters = json!({
"rootOrderIds": [123456789,223456789]
});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/cancelOrders"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"rootOrderIds": [123456789,223456789] }
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = CancelOrder();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> CancelOrder()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/cancelOrders";
var reqBody = "{ \"rootOrderIds\": [123456789,223456789] }";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/cancelOrders"
let reqBodyStr = """
{
"rootOrderIds": [123456789,223456789]
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": {
"success": [
{
"clientOrderId": "abc123",
"rootOrderId": 123456789
},
{
"rootOrderId": 223456789
}
]
},
"responsetime": "2019-03-19T01:07:24.557Z"
}
Cancels orders
- One of
rootOrderIdsclientOrderIdsis required. Both cannot be set at the same time. - It is possible to cancel max 10 orders
Request
POST /private/v1/cancelOrders
Parameters
- Parameter content type:
application/json
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| rootOrderIds | array | * |
Either rootOrderIds or clientOrderIds is required.※Up to 10 parent root order IDs can be specified |
| clientOrderIds | array | * |
Either rootOrderIds or clientOrderIds is required.※Up to 10 parent client order IDs can be specified |
Response
| Property Name | Value | Description |
|---|---|---|
| success | array | Root order ID and client order ID that succeeded to accept cancellation ※Client order ID returned only if set |
Cancel Bulk Order
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/cancelBulkOrder';
const reqBody = JSON.stringify({
symbols: ["USD_JPY","CAD_JPY"],
side: "BUY",
settleType: "OPEN"
})
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/cancelBulkOrder'
reqBody = {
"symbols": ["USD_JPY","CAD_JPY"],
"side": "BUY",
"settleType": "OPEN"
}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/cancelBulkOrder"
reqBody := (`{
"symbols": ["USD_JPY","CAD_JPY"],
"side": "BUY",
"settleType": "OPEN"
}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/cancelBulkOrder'
reqBody = {
:symbols => ['USD_JPY','CAD_JPY'],
:side => 'BUY',
:settleType => 'OPEN'
}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/cancelBulkOrder"
var reqBody = """
{"symbols": ["USD_JPY","CAD_JPY"],
"side": "BUY",
"settleType": "OPEN"
}
"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/cancelBulkOrder';
$reqBody = '{
"symbols": ["USD_JPY","CAD_JPY"],
"side": "BUY",
"settleType": "OPEN"
}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
cancel_bulk_order().unwrap();
}
fn cancel_bulk_order() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/cancelBulkOrder";
let parameters = json!({
"symbols": ["USD_JPY","CAD_JPY"],
"side": "BUY",
"settleType": "OPEN"
});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/cancelBulkOrder"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"symbols": ["USD_JPY","CAD_JPY"],
"side": "BUY",
"settleType": "OPEN"
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = CancelOrder();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> CancelOrder()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/cancelBulkOrder";
var reqBody = "{ \"symbols\": [\"USD_JPY\",\"CAD_JPY\"], " +
"\"side\": \"BUY\", " +
"\"settleType\": \"OPEN\"}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/cancelBulkOrder"
let reqBodyStr = """
{
"symbols": ["USD_JPY","CAD_JPY"],
"side": "BUY",
"settleType": "OPEN"
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": {
"success": [
{
"clientOrderId": "abc123",
"rootOrderId": 123456789
},
{
"rootOrderId": 223456789
}
]
},
"responsetime": "2019-03-19T01:07:24.557Z"
}
Cancel a batch of orders (both normal and special orders).
- After searching for cancellation targets, cancel all target orders.
- In IFD and IFDOCO cases where the first order has not been executed, the entire order will be cancelled if there is first or second order that matches both side and settleType.
- In IFD and IFDOCO cases where the first order has been executed, if the second order has both side and settleType matching, the second order is cancelled.
Request
POST /private/v1/cancelBulkOrder
Parameters
- Parameter content type:
application/json
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| symbols | array | Required |
The handling symbols are here |
| side | string | Optional | BUY SELL※Only when parameters are specified, orders with the specified side parameter are subject to cancellation. |
| settleType | string | Optional | OPEN CLOSE※Only when parameters are specified, orders with the specified settlement type are subject to cancellation. |
Response
| Property Name | Value | Description |
|---|---|---|
| success | array | Root order ID and client order ID that succeeded to accept cancellation ※Client order ID returned only if set |
Close Order
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/closeOrder';
const reqBody = JSON.stringify({
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "135.5",
"settlePosition": [
{
"positionId": 1000342,
"size": "10000"
}
]
})
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/closeOrder'
reqBody = {
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "135.5",
"settlePosition": [
{
"positionId": 1000342,
"size": "10000"
}
]
}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/closeOrder"
reqBody := (`{
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "135.5",
"settlePosition": [
{
"positionId": 1000342,
"size": "10000"
}
]
}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/closeOrder'
reqBody = {
:symbol => 'USD_JPY',
:side => 'BUY',
:clientOrderId => 'abc123',
:executionType => 'LIMIT',
:limitPrice => '135.5',
:settlePosition => [
{
:positionId => 1000342,
:size => '10000'
}
]
}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/closeOrder"
var reqBody = """
{
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "135.5",
"settlePosition": [
{
"positionId": 1000342,
"size": "10000"
}
]}
"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/closeOrder';
$reqBody = '{
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "135.5",
"settlePosition": [
{
"positionId": 1000342,
"size": "10000"
}
]
}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
close_order().unwrap();
}
fn close_order() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/closeOrder";
let parameters = json!({
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "135.5",
"settlePosition": [
{
"positionId": 1000342,
"size": "10000"
}
]
});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/closeOrder"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "135.5",
"settlePosition": [
{
"positionId": 1000342,
"size": "10000"
}
]}
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = CloseOrder();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> CloseOrder()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/closeOrder";
var reqBody = "{ \"symbol\": \"USD_JPY\", " +
"\"side\": \"BUY\", " +
"\"clientOrderId\": \"abc123\", " +
"\"executionType\": \"LIMIT\", " +
"\"limitPrice\": \"135.5\", " +
"\"settlePosition\": [ { \"positionId\": 1000342, \"size\": \"10000\" } ] }";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/closeOrder"
let reqBodyStr = """
{
"symbol": "USD_JPY",
"side": "BUY",
"clientOrderId": "abc123",
"executionType": "LIMIT",
"limitPrice": "135.5",
"settlePosition": [
{
"positionId": 1000342,
"size": "10000"
}
]
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": [
{
"rootOrderId": 123456789,
"clientOrderId": "abc123",
"orderId": 123456789,
"symbol": "USD_JPY",
"side": "BUY",
"orderType": "NORMAL",
"executionType": "LIMIT",
"settleType": "CLOSE",
"size": "10000",
"price": "135.5",
"status": "WAITING",
"expiry": "20230418",
"timestamp": "2019-03-19T01:07:24.467Z"
}
],
"responsetime": "2019-03-19T01:07:24.557Z"
}
Closes a position
- ※One of
sizesettlePositionis required. Both cannot be set at the same time.
Request
POST /private/v1/closeOrder
Parameters
- Parameter content type:
application/json
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| symbol | string | Required |
The handling symbols are here |
| side | string | Required |
BUY SELL |
| executionType | string | Required |
MARKET LIMIT STOP OCO |
| clientOrderId | string | Optional | Client order id ※Only combinations of up to 36 single-byte alphanumeric characters can be used. |
| size | string | * |
Quantity of the order No open interest specified.※Either size or settlePosition is required. |
| limitPrice | string | *Depending on executionType |
Order rate ※Required if LIMIT OCO . Not required if |
| stopPrice | string | *Depending on executionType |
Order rate ※Required if STOP OCO . Not required if |
| lowerBound | string | Optional | Maximum price ※Can be specified for executionType: MARKET side: SELL. |
| upperBound | string | Optional | Maximum price ※Can be specified for executionType: MARKET side: BUY. |
| settlePostion | array | * |
Multi-position Multiple designations possible※Either size or settlePosition is required.※Up to 10 can be specified |
| settlePosition.positionId | number | * |
Open interest ID |
| settlePosition.size | string | * |
Quantity of the order |
Response
| Property Name | Value | Description |
|---|---|---|
| rootOrderId | number | Root order id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| orderType | string | Order Type: NORMAL OCO |
| executionType | string | Execution Type: MARKET LIMIT STOP |
| settleType | string | Settlement Type: CLOSE |
| size | string | Quantity of the order |
| price | string | Price of the order ※It is returned if status is LIMIT or STOP. |
| status | string | Order Status: WAITING EXECUTED EXPIRED |
| cancelType | string | Cancel Type: PRICE_BOUND OCO ※It is returned if status is EXPIRED. |
| expiry | string | Expiry date |
| timestamp | string | Ordered timestamp |
Private WebSocket API
- A ping will be sent from the server to a client once per minute. If there's no response (pong) from a client 3 consecutive times, then the WebSocket will be disconnected automatically.
- Using a Private API for authentication in order to obtain, extend and remove the access token.
- A Private WebSocket API's URL will be
Endpoint of Private WebSocket API + Access token
e.g.wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx
Create Access Token
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'POST';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/ws-auth';
const reqBody = JSON.stringify({});
const text = timestamp + method + path + reqBody;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.post(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/ws-auth'
reqBody = {}
text = timestamp + method + path + json.dumps(reqBody)
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.post(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "POST"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/ws-auth"
reqBody := (`{}`)
text := timestamp + method + path + reqBody
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'POST'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/ws-auth'
reqBody = {}
text = timestamp + method + path + reqBody.to_json
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Post.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "POST"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/ws-auth"
var reqBody = """{}"""
var text = timestamp + method + path + reqBody
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'POST';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/ws-auth';
$reqBody = '{}';
$text = $timestamp . $method . $path . $reqBody;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
ws_auth_post().unwrap();
}
fn ws_auth_post() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "POST";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/ws-auth";
let parameters = json!({});
let text = format!("{}{}{}{}", timestamp, method, path, ¶meters);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.post(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "POST"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/ws-auth"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {}
|]
let requestBodyBS = S8.toStrict $ encode requestBodyJson
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path <> requestBodyBS)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "POST"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = WsAuthPost();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> WsAuthPost()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "POST";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/ws-auth";
var reqBody = "{}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path + reqBody;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "POST"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/ws-auth"
let reqBodyStr = """
{}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path + reqBodyStr
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"data": "xxxxxxxxxxxxxxxxxxxx",
"responsetime": "2019-03-19T02:15:06.102Z"
}
Gets an access token to call Private WebSocket API.
- The expiration time of access token is 60 minutes.
- The maximum number of access tokens is 5.
- If the number of issued tokens exceeds the maximum number of tokens, the tokens will be deleted in order of expiration time.
- To use the API with the existing API keys, open your membership site > API > 編集 (Edit) > APIキーの編集 (API key setting) screen and click "約定情報通知(WebSocket)" (Execution Notifications), "注文情報通知(WebSocket)" (Order Notifications), "ポジション情報通知(WebSocket)" (Position Notifications) or "ポジションサマリー情報通知(WebSocket)" (Position Summary Notifications) to call the Create Access Token API.
※Please set the API key permission before obtaining the access token.
Request
POST /private/v1/ws-auth
Parameters
None
Response
| Property Name | Value | Description |
|---|---|---|
| data | string | Access token |
Extend Access Token
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'PUT';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/ws-auth';
const reqBody = JSON.stringify({
"token": "xxxxxxxxxxxxxxxxxxxx"
})
const text = timestamp + method + path;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
};
axios.put(endPoint + path, reqBody, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'PUT'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/ws-auth'
reqBody = {
"token": "xxxxxxxxxxxxxxxxxxxx"
}
text = timestamp + method + path
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.put(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "PUT"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/ws-auth"
reqBody := (`{
"token": "xxxxxxxxxxxxxxxxxxxx"
}`)
text := timestamp + method + path
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'PUT'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/ws-auth'
reqBody = {
:token => 'xxxxxxxxxxxxxxxxxxxx'
}
text = timestamp + method + path
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Put.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "PUT"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/ws-auth"
var reqBody = """
{"token": "xxxxxxxxxxxxxxxxxxxx"}
"""
var text = timestamp + method + path
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'PUT';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/ws-auth';
$reqBody = '{
"token": "xxxxxxxxxxxxxxxxxxxx"
}';
$text = $timestamp . $method . $path;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
ws_auth_put().unwrap();
}
fn ws_auth_put() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "PUT";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/ws-auth";
let parameters = json!({
"token": "xxxxxxxxxxxxxxxxxxxx"
});
let text = format!("{}{}{}", timestamp, method, path);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.put(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "PUT"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/ws-auth"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"token": "xxxxxxxxxxxxxxxxxxxx" }
|]
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "PUT"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = WsAuthPut();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> WsAuthPut()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "PUT";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/ws-auth";
var reqBody = "{ \"token\": \"xxxxxxxxxxxxxxxxxxxx\"}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "PUT"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/ws-auth"
let reqBodyStr = """
{
"token": "xxxxxxxxxxxxxxxxxxxx"
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"responsetime": "2019-03-19T02:15:06.102Z"
}
Extends the expiration time of an access token.
- The new expiration time is 60 minutes.
Request
PUT /private/v1/ws-auth
Parameters
- Parameter type: JSON
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| token | string | Required |
Access token |
Delete Access Token
Request example:
const axios = require('axios');
const crypto = require('crypto');
const apiKey = 'YOUR_API_KEY';
const secretKey = 'YOUR_SECRET_KEY';
const timestamp = Date.now().toString();
const method = 'DELETE';
const endPoint = 'https://forex-api.coin.z.com/private';
const path = '/v1/ws-auth';
const reqBody = JSON.stringify({
"token": "xxxxxxxxxxxxxxxxxxxx"
})
const text = timestamp + method + path;
const sign = crypto.createHmac('sha256', secretKey).update(text).digest('hex');
const options = {
"headers": {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
},
"data": reqBody,
};
axios.delete(endPoint + path, options)
.then(function (response) {
console.log(response.data);
})
.catch(function (error) {
console.log(error);
});
import requests
import json
import hmac
import hashlib
import time
from datetime import datetime
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = '{0}000'.format(int(time.mktime(datetime.now().timetuple())))
method = 'DELETE'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/ws-auth'
reqBody = {
"token": "xxxxxxxxxxxxxxxxxxxx"
}
text = timestamp + method + path
sign = hmac.new(bytes(secretKey.encode('ascii')), bytes(text.encode('ascii')), hashlib.sha256).hexdigest()
headers = {
"API-KEY": apiKey,
"API-TIMESTAMP": timestamp,
"API-SIGN": sign
}
res = requests.delete(endPoint + path, headers=headers, data=json.dumps(reqBody))
print (json.dumps(res.json(), indent=2))
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
"net/http"
"strconv"
"strings"
"time"
"encoding/json"
"bytes"
)
func main() {
apiKey := "YOUR_API_KEY"
secretKey := "YOUR_SECRET_KEY"
timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)
method := "DELETE"
endPoint := "https://forex-api.coin.z.com/private"
path := "/v1/ws-auth"
reqBody := (`{
"token": "xxxxxxxxxxxxxxxxxxxx"
}`)
text := timestamp + method + path
hc := hmac.New(sha256.New, []byte(secretKey))
hc.Write([]byte(text))
sign := hex.EncodeToString(hc.Sum(nil))
client := &http.Client{}
req, _ := http.NewRequest(method, endPoint+path, strings.NewReader(reqBody))
req.Header.Set("API-KEY", apiKey)
req.Header.Set("API-TIMESTAMP", timestamp)
req.Header.Set("API-SIGN", sign)
res, _ := client.Do(req)
body, _ := io.ReadAll(res.Body)
var buf bytes.Buffer
json.Indent(&buf, body, "", " ")
fmt.Println(buf.String())
}
require 'net/http'
require 'json'
require 'openssl'
require 'base64'
require 'date'
apiKey = 'YOUR_API_KEY'
secretKey = 'YOUR_SECRET_KEY'
timestamp = DateTime.now.strftime('%Q')
method = 'DELETE'
endPoint = 'https://forex-api.coin.z.com/private'
path = '/v1/ws-auth'
reqBody = {
:token => 'xxxxxxxxxxxxxxxxxxxx'
}
text = timestamp + method + path
sign = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, secretKey, text)
uri = URI.parse(endPoint + path)
req = Net::HTTP::Delete.new(uri.to_s)
req['API-KEY'] = apiKey
req['API-TIMESTAMP'] = timestamp
req['API-SIGN'] = sign
req.body = reqBody.to_json
response = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') {|http|
http.request(req)
}
puts JSON.pretty_generate(JSON.parse(response.body), :indent=>' ')
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import kotlin.experimental.and
fun main() {
var apiKey = "YOUR_API_KEY"
var secretKey = "YOUR_SECRET_KEY"
var timestamp = Calendar.getInstance().timeInMillis.toString()
var method = "DELETE"
var endPoint = "https://forex-api.coin.z.com/private"
var path = "/v1/ws-auth"
var reqBody = """
{"token": "xxxxxxxxxxxxxxxxxxxx"}
"""
var text = timestamp + method + path
var keySpec = SecretKeySpec(secretKey.toByteArray(), "HmacSHA256")
var mac = Mac.getInstance("HmacSHA256")
mac.init(keySpec)
var sign = mac.doFinal(text.toByteArray()).joinToString("") { String.format("%02x", it and 255.toByte()) }
var url = URL(endPoint + path)
var urlConnection = url.openConnection() as HttpURLConnection
urlConnection.requestMethod = method
urlConnection.addRequestProperty("API-KEY", apiKey)
urlConnection.addRequestProperty("API-TIMESTAMP", timestamp)
urlConnection.addRequestProperty("API-SIGN", sign)
urlConnection.doOutput = true
urlConnection.outputStream.write(reqBody.toByteArray())
BufferedReader(InputStreamReader(urlConnection.inputStream))
.readLines().forEach { line ->
println(JSONObject(line).toString(2))
}
}
<?php
$apiKey = 'YOUR_API_KEY';
$secretKey = 'YOUR_SECRET_KEY';
$timestamp = time() . '000';
$method = 'DELETE';
$endPoint = 'https://forex-api.coin.z.com/private';
$path = '/v1/ws-auth';
$reqBody = '{
"token": "xxxxxxxxxxxxxxxxxxxx"
}';
$text = $timestamp . $method . $path;
$sign = hash_hmac('SHA256', $text, $secretKey);
$curl = curl_init($endPoint . $path);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
$headers = array(
"Content-Type: application/json",
"API-KEY:" . $apiKey,
"API-TIMESTAMP:" . $timestamp,
"API-SIGN:" . $sign
);
curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
curl_setopt($curl, CURLOPT_POSTFIELDS, $reqBody);
$response = curl_exec($curl);
curl_close($curl);
$json_res = json_decode($response);
echo json_encode($json_res, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
#![deny(warnings)]
extern crate reqwest;
extern crate time;
extern crate serde;
extern crate serde_json;
extern crate hex;
extern crate ring;
use std::time::{SystemTime, UNIX_EPOCH};
use serde_json::json;
use hex::encode as hex_encode;
use ring::hmac;
#[warn(unused_must_use)]
fn main() {
ws_auth_delete().unwrap();
}
fn ws_auth_delete() -> Result<(), Box<dyn std::error::Error>> {
let api_key = "YOUR_API_KEY";
let secret_key = "YOUR_SECRET_KEY";
let timestamp = get_timestamp();
let method = "DELETE";
let endpoint = "https://forex-api.coin.z.com/private";
let path = "/v1/ws-auth";
let parameters = json!({
"token": "xxxxxxxxxxxxxxxxxxxx"
});
let text = format!("{}{}{}", timestamp, method, path);
let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let sign = hex_encode(hmac::sign(&signed_key, text.as_bytes()).as_ref());
let client = reqwest::blocking::Client::new();
let mut res = client.delete(&(endpoint.to_string() + path))
.header("content-type", "application/json")
.header("API-KEY", api_key)
.header("API-TIMESTAMP", timestamp)
.header("API-SIGN", sign)
.json(¶meters)
.send()
.unwrap();
res.copy_to(&mut std::io::stdout())?;
Ok(())
}
fn get_timestamp() -> u64 {
let start = SystemTime::now();
let since_epoch = start.duration_since(UNIX_EPOCH).expect("Time went backwards", );
since_epoch.as_secs() * 1000 + since_epoch.subsec_nanos() as u64 / 1_000_000
}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
module Main where
import Crypto.Hash.SHA256 as SHA256
import Data.Aeson (encode)
import Data.Aeson (Value)
import Data.Aeson.Encode.Pretty
import qualified Data.Aeson.QQ as Aeson.QQ
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy.Char8 as S8
import Data.Monoid ((<>))
import qualified Data.String as S
import Data.Time.Clock.POSIX (getPOSIXTime)
import Network.HTTP.Simple
apiKey :: B.ByteString
apiKey = "YOUR_API_KEY"
secretKey :: B.ByteString
secretKey = "YOUR_SECRET_KEY"
method :: B.ByteString
method = "DELETE"
endPoint :: S.String
endPoint = "https://forex-api.coin.z.com/private"
path :: S.String
path = "/v1/ws-auth"
main :: IO ()
main = do
posixTime <- getPOSIXTime
let epochTime = BS.pack . show . round $ posixTime
let timestamp = epochTime <> "000"
let requestBodyJson =
[Aeson.QQ.aesonQQ| {
"token": "xxxxxxxxxxxxxxxxxxxx" }
|]
let sign = B16.encode $ SHA256.hmac secretKey (timestamp <> method <> BS.pack path)
let url = endPoint <> path
request' <- parseRequest url
let request
= setRequestMethod "DELETE"
$ setRequestSecure True
$ setRequestPort 443
$ setRequestHeader "API-KEY" [apiKey]
$ setRequestHeader "API-TIMESTAMP" [timestamp]
$ setRequestHeader "API-SIGN" [sign]
$ setRequestBodyJSON requestBodyJson
$ request'
response <- httpJSON request
S8.putStrLn $ encodePretty (getResponseBody response :: Value)
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
class Example
{
static readonly HttpClient HttpClient = new HttpClient();
public static void Main(string[] args)
{
var task = WsAuthDelete();
task.Wait();
Console.WriteLine(task.Result);
}
static async Task<String> WsAuthDelete()
{
const string apiKey = "YOUR_API_KEY";
const string secretKey = "YOUR_SECRET_KEY";
var timestamp = ((long) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds).ToString() + "000";
const string method = "DELETE";
const string endpoint = "https://forex-api.coin.z.com/private";
const string path = "/v1/ws-auth";
var reqBody = "{ \"token\": \"xxxxxxxxxxxxxxxxxxxx\"}";
using (var request = new HttpRequestMessage(new HttpMethod(method), endpoint + path))
using (var content = new StringContent(reqBody))
{
var text = timestamp + method + path;
var hmacsha256 = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey));
var hash = hmacsha256.ComputeHash(Encoding.UTF8.GetBytes(text));
var sign = ToHexString(hash);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content = content;
request.Headers.Add("API-KEY", apiKey);
request.Headers.Add("API-TIMESTAMP", timestamp);
request.Headers.Add("API-SIGN", sign);
var response = await HttpClient.SendAsync(request);
return await response.Content.ReadAsStringAsync();
}
}
static string ToHexString(byte[] bytes)
{
var sb = new StringBuilder(bytes.Length * 2);
foreach (var b in bytes)
{
sb.Append(b.ToString("x2"));
}
return sb.ToString();
}
}
import Foundation
import CommonCrypto
extension Data {
var prettyPrintedJSONString: NSString? {
guard let object = try? JSONSerialization.jsonObject(with: self, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
}
}
extension String {
func hmac(secretKey: String) -> String {
let text = self.cString(using: String.Encoding.utf8)
let textLen = Int(self.lengthOfBytes(using: String.Encoding.utf8))
let digestLen = Int(CC_SHA256_DIGEST_LENGTH)
let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
let secretKeyStr = secretKey.cString(using: String.Encoding.utf8)
let secretKeyLen = Int(secretKey.lengthOfBytes(using: String.Encoding.utf8))
CCHmac(CCHmacAlgorithm(kCCHmacAlgSHA256), secretKeyStr!, secretKeyLen, text!, textLen, result)
let digest = stringFromResult(result: result, length: digestLen)
result.deallocate()
return digest
}
private func stringFromResult(result: UnsafeMutablePointer<CUnsignedChar>, length: Int) -> String {
let hash = NSMutableString()
for i in 0..<length {
hash.appendFormat("%02x", result[i])
}
return String(hash)
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let apiKey = "YOUR_API_KEY"
let secretKey = "YOUR_SECRET_KEY"
let timestamp = String(Int64((Date().timeIntervalSince1970 * 1000.0).rounded()))
let method = "DELETE"
let endPoint : String = "https://forex-api.coin.z.com/private"
let path : String = "/v1/ws-auth"
let reqBodyStr = """
{
"token": "xxxxxxxxxxxxxxxxxxxx"
}
"""
let reqBodyData = reqBodyStr.data(using: .utf8)!
let text = timestamp + method + path
let sign = text.hmac(secretKey: secretKey)
var request = URLRequest(url: URL(string: endPoint + path)!)
request.httpMethod = method
request.httpBody = reqBodyData
request.setValue(apiKey, forHTTPHeaderField: "API-KEY")
request.setValue(timestamp, forHTTPHeaderField: "API-TIMESTAMP")
request.setValue(sign, forHTTPHeaderField: "API-SIGN")
let task = URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
print(data!.prettyPrintedJSONString!)
dispatchGroup.leave()
})
task.resume()
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"status": 0,
"responsetime": "2019-03-19T02:15:06.102Z"
}
Deletes an access token.
Request
DELETE /private/v1/ws-auth
Parameters
- Parameter type: JSON
| Parameter | Type | Required | Available Values |
|---|---|---|---|
| token | string | Required |
Access token |
Execution Notifications
Request example:
const WebSocket = require("ws");
const ws = new WebSocket("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx");
ws.on("open", () => {
const message = JSON.stringify(
{
"command": "subscribe",
"channel": "executionEvents"
});
ws.send(message);
});
ws.on("message", (data) => {
console.log("WebSocket message: ", data);
});
import json
import websocket
websocket.enableTrace(True)
ws = websocket.WebSocketApp('wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx')
def on_open(self):
message = {
"command": "subscribe",
"channel": "executionEvents"
}
ws.send(json.dumps(message))
def on_message(self, message):
print(message)
ws.on_open = on_open
ws.on_message = on_message
ws.run_forever()
package main
import (
"fmt"
"golang.org/x/net/websocket"
"encoding/json"
"bytes"
)
func main() {
wsUrl := "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx"
origin := "https://forex-api.coin.z.com"
sendMsg := (`{
"command": "subscribe",
"channel": "executionEvents"
}`)
var receiveMsg string
ws, _ := websocket.Dial(wsUrl, "", origin)
websocket.Message.Send(ws, sendMsg)
for {
websocket.Message.Receive(ws, &receiveMsg)
var buf bytes.Buffer
json.Indent(&buf, []byte(receiveMsg), "", " ")
fmt.Println(buf.String())
}
}
require "faye/websocket"
require "eventmachine"
require 'json'
EM.run {
ws = Faye::WebSocket::Client.new("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")
ws.on :open do |event|
message = {
:command => "subscribe",
:channel => "executionEvents"
}
ws.send(message.to_json)
end
ws.on :message do |event|
puts event.data
end
}
import io.ktor.client.HttpClient
import io.ktor.client.features.websocket.WebSockets
import io.ktor.client.features.websocket.webSocket
import io.ktor.http.cio.websocket.Frame
import io.ktor.http.cio.websocket.readText
import kotlinx.coroutines.runBlocking
import org.json.JSONObject
fun main() {
var wsUrl = "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx"
var sendMsg = """
{"command": "subscribe",
"channel": "executionEvents"}
"""
val client = HttpClient {
install(WebSockets)
}
runBlocking {
client.webSocket(
urlString = wsUrl
) {
send(Frame.Text(sendMsg))
while (true) {
val frame = incoming.receive()
when (frame) {
is Frame.Text -> println(JSONObject(frame.readText()).toString(2))
else -> {}
}
}
}
}
}
<?php
// Required installing ratchet/pawl with a command below before running the code.
// composer require ratchet/pawl
require __DIR__ . '/vendor/autoload.php';
$loop = \React\EventLoop\Factory::create();
$reactConnector = new \React\Socket\Connector($loop);
$connector = new \Ratchet\Client\Connector($loop, $reactConnector);
$connector("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")->then(function (Ratchet\Client\WebSocket $conn) use ($connector, $loop) {
$conn->on('message', function (\Ratchet\RFC6455\Messaging\MessageInterface $msg) use ($conn) {
echo "{$msg}\n";
});
$conn->on('close', function ($code = null, $reason = null) {
echo "Connection closed ({$code} - {$reason})\n";
});
$conn->send('{ "command" : "subscribe", "channel" : "executionEvents" }');
}, function (\Exception $e) use ($loop) {
echo "Could not connect: {$e->getMessage()}\n";
$loop->stop();
});
$loop->run();
#![deny(warnings)]
extern crate tungstenite;
extern crate url;
use tungstenite::{connect, Message};
use url::Url;
fn main() {
execution_events_ws();
}
fn execution_events_ws() {
let (mut socket, _response) =
connect(Url::parse("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx").unwrap()).expect("Can't connect");
socket
.write_message(Message::Text("{ \"command\" : \"subscribe\", \"channel\": \"executionEvents\" }".into()))
.unwrap();
loop {
let msg = socket.read_message().expect("Error reading message");
println!("{}", msg);
}
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Control.Concurrent (forkIO)
import Control.Monad (forever, unless)
import Control.Monad.Trans (liftIO)
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Network.Socket (withSocketsDo)
import qualified Network.WebSockets as WS
import qualified Wuss as WSS (runSecureClient)
app :: WS.ClientApp ()
app conn = do
putStrLn "Connected!"
WS.sendTextData conn ("{ \"command\" : \"subscribe\", \"channel\": \"executionEvents\" }" :: Text)
_ <- forkIO $ forever $ do
msg <- WS.receiveData conn
liftIO $ T.putStrLn msg
let loop = do
line <- T.getLine
unless (T.null line) $ WS.sendTextData conn line >> loop
loop
WS.sendClose conn ("msgData" :: Text)
main :: IO ()
main = withSocketsDo $ WSS.runSecureClient "forex-api.coin.z.com" 443 "/ws/private/v1/xxxxxxxxxxxxxxxxxxxx" app
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
class Example
{
public static void Main(string[] args)
{
var task = ExecutionEvents();
task.Wait();
}
static async Task ExecutionEvents()
{
const string endpoint = "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx";
const string message = "{ \"command\" : \"subscribe\", \"channel\": \"executionEvents\" }";
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(endpoint), CancellationToken.None);
var messageBytes = Encoding.UTF8.GetBytes(message);
await client.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, true,
CancellationToken.None);
while (client.State == WebSocketState.Open)
{
var incomingData = new byte[1024];
var result = await client.ReceiveAsync(new ArraySegment<byte>(incomingData), CancellationToken.None);
Console.WriteLine(Encoding.UTF8.GetString(incomingData, 0, result.Count));
}
}
}
}
// WebSocket4Net example
using System;
using WebSocket4Net;
class Example
{
static WebSocket websocket;
static void Main(string[] args)
{
websocket = new WebSocket("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx");
websocket.Opened += Websocket_Opened;
websocket.MessageReceived += Websocket_MessageReceived;
websocket.Open();
Console.Read();
}
private static void Websocket_Opened(object sender, EventArgs e)
{
const string message = "{ \"command\" : \"subscribe\", \"channel\": \"executionEvents\" }";
websocket.Send(message);
}
private static void Websocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
Console.WriteLine(e.Message);
}
}
import Foundation
extension URLSessionWebSocketTask.Message {
var prettyPrintedJSONString: NSString? {
switch self {
case .string(let text):
guard let object = try? JSONSerialization.jsonObject(with: text.data(using: .utf8)!, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
default:
return nil
}
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let url = URL(string: "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")!
let urlSession = URLSession(configuration: .default)
let webSocketTask = urlSession.webSocketTask(with: url)
webSocketTask.resume()
let message = URLSessionWebSocketTask.Message.string("""
{
"command": "subscribe",
"channel": "executionEvents"
}
""")
webSocketTask.send(message) { error in
if let error = error {
print(error)
}
}
webSocketTask.receive { result in
switch result {
case .failure(let error):
print(error)
case .success(let message):
print(message.prettyPrintedJSONString!)
dispatchGroup.leave()
}
}
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"channel": "executionEvents",
"amount": "-30",
"rootOrderId": 123456789,
"orderId": 123456789,
"clientOrderId": "abc123",
"executionId": 72123911,
"symbol": "USD_JPY",
"settleType": "OPEN",
"orderType": "NORMAL",
"executionType": "LIMIT",
"side": "BUY",
"executionPrice": "138.963",
"executionSize": "10000",
"positionId": 123456789,
"lossGain": "0",
"settledSwap": "0",
"fee": "-30",
"orderPrice": "140",
"orderExecutedSize": "10000",
"orderSize": "10000",
"msgType": "ER",
"orderTimestamp": "2019-03-19T02:15:06.081Z",
"executionTimestamp": "2019-03-19T02:15:06.081Z"
}
Receives latest execution events notifications.
After subscribe, latest execution events notification will be sent.
Parameters
- Parameter type: JSON
| Property Name | Type | Required | Available Values |
|---|---|---|---|
| command | string | Required |
subscribe unsubscribe |
| channel | string | Required |
executionEvents |
Response
| Property Name | Value | Description |
|---|---|---|
| channel | string | executionEvents |
| amount | string | Delivery amount |
| rootOrderId | number | Root order id |
| orderId | number | Order id |
| clientOrderId | string | Client order id ※Returned only when set |
| executionId | number | Execution id |
| symbol | string | The handling symbols are here |
| settleType | string | Settlement Type: OPEN CLOSE |
| orderType | string | Order Type: NORMAL OCO IFD IFDOCO LOSSCUT |
| executionType | string | Execution Type: MARKET LIMIT STOP |
| side | string | Side: BUY SELL |
| executionPrice | string | Executed price |
| executionSize | string | Executed quantity |
| positionId | number | Position id |
| lossGain | string | Settlement profit/loss |
| settledSwap | string | Settlement profit/loss of swap |
| fee | string | Trade fee |
| orderPrice | string | Price of the order ※It is returned if status is LIMIT or STOP. |
| orderExecutedSize | string | Contracted Quantity |
| orderSize | string | Order size |
| msgType | string | Message Type: ER |
| orderTimestamp | string | Ordered timestamp |
| executionTimestamp | string | Executed timestamp |
- There is no Response when
unsubscribeis requested.
Order Notifications
Request example:
const WebSocket = require("ws");
const ws = new WebSocket("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx");
ws.on("open", () => {
const message = JSON.stringify(
{
"command": "subscribe",
"channel": "orderEvents"
});
ws.send(message);
});
ws.on("message", (data) => {
console.log("WebSocket message: ", data);
});
import json
import websocket
websocket.enableTrace(True)
ws = websocket.WebSocketApp('wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx')
def on_open(self):
message = {
"command": "subscribe",
"channel": "orderEvents"
}
ws.send(json.dumps(message))
def on_message(self, message):
print(message)
ws.on_open = on_open
ws.on_message = on_message
ws.run_forever()
package main
import (
"fmt"
"golang.org/x/net/websocket"
"encoding/json"
"bytes"
)
func main() {
wsUrl := "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx"
origin := "https://forex-api.coin.z.com"
sendMsg := (`{
"command": "subscribe",
"channel": "orderEvents"
}`)
var receiveMsg string
ws, _ := websocket.Dial(wsUrl, "", origin)
websocket.Message.Send(ws, sendMsg)
for {
websocket.Message.Receive(ws, &receiveMsg)
var buf bytes.Buffer
json.Indent(&buf, []byte(receiveMsg), "", " ")
fmt.Println(buf.String())
}
}
require "faye/websocket"
require "eventmachine"
require 'json'
EM.run {
ws = Faye::WebSocket::Client.new("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")
ws.on :open do |event|
message = {
:command => "subscribe",
:channel => "orderEvents"
}
ws.send(message.to_json)
end
ws.on :message do |event|
puts event.data
end
}
import io.ktor.client.HttpClient
import io.ktor.client.features.websocket.WebSockets
import io.ktor.client.features.websocket.webSocket
import io.ktor.http.cio.websocket.Frame
import io.ktor.http.cio.websocket.readText
import kotlinx.coroutines.runBlocking
import org.json.JSONObject
fun main() {
var wsUrl = "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx"
var sendMsg = """
{"command": "subscribe",
"channel": "orderEvents"}
"""
val client = HttpClient {
install(WebSockets)
}
runBlocking {
client.webSocket(
urlString = wsUrl
) {
send(Frame.Text(sendMsg))
while (true) {
val frame = incoming.receive()
when (frame) {
is Frame.Text -> println(JSONObject(frame.readText()).toString(2))
else -> {}
}
}
}
}
}
<?php
// Required installing ratchet/pawl with a command below before running the code.
// composer require ratchet/pawl
require __DIR__ . '/vendor/autoload.php';
$loop = \React\EventLoop\Factory::create();
$reactConnector = new \React\Socket\Connector($loop);
$connector = new \Ratchet\Client\Connector($loop, $reactConnector);
$connector("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")->then(function (Ratchet\Client\WebSocket $conn) use ($connector, $loop) {
$conn->on('message', function (\Ratchet\RFC6455\Messaging\MessageInterface $msg) use ($conn) {
echo "{$msg}\n";
});
$conn->on('close', function ($code = null, $reason = null) {
echo "Connection closed ({$code} - {$reason})\n";
});
$conn->send('{ "command" : "subscribe", "channel" : "orderEvents" }');
}, function (\Exception $e) use ($loop) {
echo "Could not connect: {$e->getMessage()}\n";
$loop->stop();
});
$loop->run();
#![deny(warnings)]
extern crate tungstenite;
extern crate url;
use tungstenite::{connect, Message};
use url::Url;
fn main() {
order_events_ws();
}
fn order_events_ws() {
let (mut socket, _response) =
connect(Url::parse("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx").unwrap()).expect("Can't connect");
socket
.write_message(Message::Text("{ \"command\" : \"subscribe\", \"channel\": \"orderEvents\" }".into()))
.unwrap();
loop {
let msg = socket.read_message().expect("Error reading message");
println!("{}", msg);
}
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Control.Concurrent (forkIO)
import Control.Monad (forever, unless)
import Control.Monad.Trans (liftIO)
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Network.Socket (withSocketsDo)
import qualified Network.WebSockets as WS
import qualified Wuss as WSS (runSecureClient)
app :: WS.ClientApp ()
app conn = do
putStrLn "Connected!"
WS.sendTextData conn ("{ \"command\" : \"subscribe\", \"channel\": \"orderEvents\" }" :: Text)
_ <- forkIO $ forever $ do
msg <- WS.receiveData conn
liftIO $ T.putStrLn msg
let loop = do
line <- T.getLine
unless (T.null line) $ WS.sendTextData conn line >> loop
loop
WS.sendClose conn ("msgData" :: Text)
main :: IO ()
main = withSocketsDo $ WSS.runSecureClient "forex-api.coin.z.com" 443 "/ws/private/v1/xxxxxxxxxxxxxxxxxxxx" app
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
class Example
{
public static void Main(string[] args)
{
var task = OrderEvents();
task.Wait();
}
static async Task OrderEvents()
{
const string endpoint = "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx";
const string message = "{ \"command\" : \"subscribe\", \"channel\": \"orderEvents\" }";
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(endpoint), CancellationToken.None);
var messageBytes = Encoding.UTF8.GetBytes(message);
await client.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, true,
CancellationToken.None);
while (client.State == WebSocketState.Open)
{
var incomingData = new byte[1024];
var result = await client.ReceiveAsync(new ArraySegment<byte>(incomingData), CancellationToken.None);
Console.WriteLine(Encoding.UTF8.GetString(incomingData, 0, result.Count));
}
}
}
}
// WebSocket4Net example
using System;
using WebSocket4Net;
class Example
{
static WebSocket websocket;
static void Main(string[] args)
{
websocket = new WebSocket("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx");
websocket.Opened += Websocket_Opened;
websocket.MessageReceived += Websocket_MessageReceived;
websocket.Open();
Console.Read();
}
private static void Websocket_Opened(object sender, EventArgs e)
{
const string message = "{ \"command\" : \"subscribe\", \"channel\": \"orderEvents\" }";
websocket.Send(message);
}
private static void Websocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
Console.WriteLine(e.Message);
}
}
import Foundation
extension URLSessionWebSocketTask.Message {
var prettyPrintedJSONString: NSString? {
switch self {
case .string(let text):
guard let object = try? JSONSerialization.jsonObject(with: text.data(using: .utf8)!, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
default:
return nil
}
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let url = URL(string: "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")!
let urlSession = URLSession(configuration: .default)
let webSocketTask = urlSession.webSocketTask(with: url)
webSocketTask.resume()
let message = URLSessionWebSocketTask.Message.string("""
{
"command": "subscribe",
"channel": "orderEvents"
}
""")
webSocketTask.send(message) { error in
if let error = error {
print(error)
}
}
webSocketTask.receive { result in
switch result {
case .failure(let error):
print(error)
case .success(let message):
print(message.prettyPrintedJSONString!)
dispatchGroup.leave()
}
}
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"channel": "orderEvents",
"rootOrderId": 123456789,
"clientOrderId":"abc123",
"orderId": 123456789,
"symbol": "USD_JPY",
"settleType": "OPEN",
"orderType": "NORMAL",
"executionType": "LIMIT",
"side": "BUY",
"orderStatus": "ORDERED",
"orderTimestamp": "2019-03-19T02:15:06.081Z",
"orderPrice": "135",
"orderSize": "10000",
"expiry" : "20190418",
"msgType": "NOR"
}
Receives latest order events notifications.
After subscribe, latest order events notification will be sent.
Parameters
- Parameter type: JSON
| Property Name | Type | Required | Available Values |
|---|---|---|---|
| command | string | Required |
subscribe unsubscribe |
| channel | string | Required |
orderEvents |
Response
| Property Name | Value | Description |
|---|---|---|
| channel | string | orderEvents |
| rootOrderId | number | Root order id |
| clientOrderId | string | Client order id ※Returned only when set |
| orderId | number | Order id |
| symbol | string | The handling symbols are here |
| settleType | string | Settlement Type: OPEN CLOSE LOSS_CUT |
| orderType | string | Order Type: NORMAL OCO IFD IFDOCO LOSSCUT |
| executionType | string | Execution Type: MARKET LIMIT STOP |
| side | string | Side: BUY SELL |
| orderStatus | string | Order Status: WAITING ORDERED CANCELED EXPIRED |
| cancelType | string | Cancel Type: USER INSUFFICIENT_COLLATERAL INSUFFICIENT_MARGIN SPEED OCO EXPIRATION PRICE_BOUND OUT_OF_SLIPPAGE_RANGE ※It is returned if status is CANCELED, or EXPIRED. |
| orderTimestamp | string | Ordered timestamp |
| orderPrice | string | Price of the order ※It is returned if status is LIMIT or STOP. |
| orderSize | string | Ordered size |
| expiry | string | Expiry date |
| msgType | string | Message Type: NOR ROR COR |
- There is no Response when
unsubscribeis requested.
Position Notifications
Request example:
const WebSocket = require("ws");
const ws = new WebSocket("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx");
ws.on("open", () => {
const message = JSON.stringify(
{
"command": "subscribe",
"channel": "positionEvents"
});
ws.send(message);
});
ws.on("message", (data) => {
console.log("WebSocket message: ", data);
});
import json
import websocket
websocket.enableTrace(True)
ws = websocket.WebSocketApp('wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx')
def on_open(self):
message = {
"command": "subscribe",
"channel": "positionEvents"
}
ws.send(json.dumps(message))
def on_message(self, message):
print(message)
ws.on_open = on_open
ws.on_message = on_message
ws.run_forever()
package main
import (
"fmt"
"golang.org/x/net/websocket"
"encoding/json"
"bytes"
)
func main() {
wsUrl := "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx"
origin := "https://forex-api.coin.z.com"
sendMsg := (`{
"command": "subscribe",
"channel": "positionEvents"
}`)
var receiveMsg string
ws, _ := websocket.Dial(wsUrl, "", origin)
websocket.Message.Send(ws, sendMsg)
for {
websocket.Message.Receive(ws, &receiveMsg)
var buf bytes.Buffer
json.Indent(&buf, []byte(receiveMsg), "", " ")
fmt.Println(buf.String())
}
}
require "faye/websocket"
require "eventmachine"
require 'json'
EM.run {
ws = Faye::WebSocket::Client.new("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")
ws.on :open do |event|
message = {
:command => "subscribe",
:channel => "positionEvents"
}
ws.send(message.to_json)
end
ws.on :message do |event|
puts event.data
end
}
import io.ktor.client.HttpClient
import io.ktor.client.features.websocket.WebSockets
import io.ktor.client.features.websocket.webSocket
import io.ktor.http.cio.websocket.Frame
import io.ktor.http.cio.websocket.readText
import kotlinx.coroutines.runBlocking
import org.json.JSONObject
fun main() {
var wsUrl = "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx"
var sendMsg = """
{"command": "subscribe",
"channel": "positionEvents"}
"""
val client = HttpClient {
install(WebSockets)
}
runBlocking {
client.webSocket(
urlString = wsUrl
) {
send(Frame.Text(sendMsg))
while (true) {
val frame = incoming.receive()
when (frame) {
is Frame.Text -> println(JSONObject(frame.readText()).toString(2))
else -> {}
}
}
}
}
}
<?php
// Required installing ratchet/pawl with a command below before running the code.
// composer require ratchet/pawl
require __DIR__ . '/vendor/autoload.php';
$loop = \React\EventLoop\Factory::create();
$reactConnector = new \React\Socket\Connector($loop);
$connector = new \Ratchet\Client\Connector($loop, $reactConnector);
$connector("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")->then(function (Ratchet\Client\WebSocket $conn) use ($connector, $loop) {
$conn->on('message', function (\Ratchet\RFC6455\Messaging\MessageInterface $msg) use ($conn) {
echo "{$msg}\n";
});
$conn->on('close', function ($code = null, $reason = null) {
echo "Connection closed ({$code} - {$reason})\n";
});
$conn->send('{ "command" : "subscribe", "channel" : "positionEvents" }');
}, function (\Exception $e) use ($loop) {
echo "Could not connect: {$e->getMessage()}\n";
$loop->stop();
});
$loop->run();
#![deny(warnings)]
extern crate tungstenite;
extern crate url;
use tungstenite::{connect, Message};
use url::Url;
fn main() {
position_events_ws();
}
fn position_events_ws() {
let (mut socket, _response) =
connect(Url::parse("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx").unwrap()).expect("Can't connect");
socket
.write_message(Message::Text("{ \"command\" : \"subscribe\", \"channel\": \"positionEvents\" }".into()))
.unwrap();
loop {
let msg = socket.read_message().expect("Error reading message");
println!("{}", msg);
}
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Control.Concurrent (forkIO)
import Control.Monad (forever, unless)
import Control.Monad.Trans (liftIO)
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Network.Socket (withSocketsDo)
import qualified Network.WebSockets as WS
import qualified Wuss as WSS (runSecureClient)
app :: WS.ClientApp ()
app conn = do
putStrLn "Connected!"
WS.sendTextData conn ("{ \"command\" : \"subscribe\", \"channel\": \"positionEvents\" }" :: Text)
_ <- forkIO $ forever $ do
msg <- WS.receiveData conn
liftIO $ T.putStrLn msg
let loop = do
line <- T.getLine
unless (T.null line) $ WS.sendTextData conn line >> loop
loop
WS.sendClose conn ("msgData" :: Text)
main :: IO ()
main = withSocketsDo $ WSS.runSecureClient "forex-api.coin.z.com" 443 "/ws/private/v1/xxxxxxxxxxxxxxxxxxxx" app
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
class Example
{
public static void Main(string[] args)
{
var task = PositionEvents();
task.Wait();
}
static async Task PositionEvents()
{
const string endpoint = "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx";
const string message = "{ \"command\" : \"subscribe\", \"channel\": \"positionEvents\" }";
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(endpoint), CancellationToken.None);
var messageBytes = Encoding.UTF8.GetBytes(message);
await client.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, true,
CancellationToken.None);
while (client.State == WebSocketState.Open)
{
var incomingData = new byte[1024];
var result = await client.ReceiveAsync(new ArraySegment<byte>(incomingData), CancellationToken.None);
Console.WriteLine(Encoding.UTF8.GetString(incomingData, 0, result.Count));
}
}
}
}
// WebSocket4Net example
using System;
using WebSocket4Net;
class Example
{
static WebSocket websocket;
static void Main(string[] args)
{
websocket = new WebSocket("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx");
websocket.Opened += Websocket_Opened;
websocket.MessageReceived += Websocket_MessageReceived;
websocket.Open();
Console.Read();
}
private static void Websocket_Opened(object sender, EventArgs e)
{
const string message = "{ \"command\" : \"subscribe\", \"channel\": \"positionEvents\" }";
websocket.Send(message);
}
private static void Websocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
Console.WriteLine(e.Message);
}
}
import Foundation
extension URLSessionWebSocketTask.Message {
var prettyPrintedJSONString: NSString? {
switch self {
case .string(let text):
guard let object = try? JSONSerialization.jsonObject(with: text.data(using: .utf8)!, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
default:
return nil
}
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let url = URL(string: "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")!
let urlSession = URLSession(configuration: .default)
let webSocketTask = urlSession.webSocketTask(with: url)
webSocketTask.resume()
let message = URLSessionWebSocketTask.Message.string("""
{
"command": "subscribe",
"channel": "positionEvents"
}
""")
webSocketTask.send(message) { error in
if let error = error {
print(error)
}
}
webSocketTask.receive { result in
switch result {
case .failure(let error):
print(error)
case .success(let message):
print(message.prettyPrintedJSONString!)
dispatchGroup.leave()
}
}
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"channel": "positionEvents",
"positionId": 1234567,
"symbol": "USD_JPY",
"side": "BUY",
"size": "500",
"orderdSize": "0",
"price": "139.772",
"lossGain": "-553.5",
"timestamp": "2019-03-19T02:15:06.094Z",
"totalSwap":"-34.4",
"msgType": "UPR"
}
Receives latest position events notifications.
After subscribe, latest position events notification will be sent.
Parameters
- Parameter type: JSON
| Property Name | Type | Required | Available Values |
|---|---|---|---|
| command | string | Required |
subscribe unsubscribe |
| channel | string | Required |
positionEvents |
Response
| Property Name | Value | Description |
|---|---|---|
| channel | string | positionEvents |
| positionId | number | Position id |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| size | string | Quantity of the position |
| orderdSize | string | Quantity of the order |
| price | string | Price of the position |
| lossGain | string | Settlement profit/loss |
| timestamp | string | Executed timestamp |
| totalSwap | string | Total swap |
| msgType | string | Message Type: OPR UPR CPR |
- There is no Response when
unsubscribeis requested.
Position Summary Notifications
Request example:
const WebSocket = require("ws");
const ws = new WebSocket("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx");
ws.on("open", () => {
const message = JSON.stringify(
{
"command": "subscribe",
"channel": "positionSummaryEvents",
"option":"PERIODIC"
});
ws.send(message);
});
ws.on("message", (data) => {
console.log("WebSocket message: ", data);
});
import json
import websocket
websocket.enableTrace(True)
ws = websocket.WebSocketApp('wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx')
def on_open(self):
message = {
"command": "subscribe",
"channel": "positionSummaryEvents",
"option":"PERIODIC"
}
ws.send(json.dumps(message))
def on_message(self, message):
print(message)
ws.on_open = on_open
ws.on_message = on_message
ws.run_forever()
package main
import (
"fmt"
"golang.org/x/net/websocket"
"encoding/json"
"bytes"
)
func main() {
wsUrl := "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx"
origin := "https://forex-api.coin.z.com"
sendMsg := (`{
"command": "subscribe",
"channel": "positionSummaryEvents",
"option":"PERIODIC"
}`)
var receiveMsg string
ws, _ := websocket.Dial(wsUrl, "", origin)
websocket.Message.Send(ws, sendMsg)
for {
websocket.Message.Receive(ws, &receiveMsg)
var buf bytes.Buffer
json.Indent(&buf, []byte(receiveMsg), "", " ")
fmt.Println(buf.String())
}
}
require "faye/websocket"
require "eventmachine"
require 'json'
EM.run {
ws = Faye::WebSocket::Client.new("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")
ws.on :open do |event|
message = {
:command => "subscribe",
:channel => "positionSummaryEvents",
:option => "PERIODIC"
}
ws.send(message.to_json)
end
ws.on :message do |event|
puts event.data
end
}
import io.ktor.client.HttpClient
import io.ktor.client.features.websocket.WebSockets
import io.ktor.client.features.websocket.webSocket
import io.ktor.http.cio.websocket.Frame
import io.ktor.http.cio.websocket.readText
import kotlinx.coroutines.runBlocking
import org.json.JSONObject
fun main() {
var wsUrl = "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx"
var sendMsg = """
{"command": "subscribe",
"channel": "positionSummaryEvents",
"option":"PERIODIC"}
"""
val client = HttpClient {
install(WebSockets)
}
runBlocking {
client.webSocket(
urlString = wsUrl
) {
send(Frame.Text(sendMsg))
while (true) {
val frame = incoming.receive()
when (frame) {
is Frame.Text -> println(JSONObject(frame.readText()).toString(2))
else -> {}
}
}
}
}
}
<?php
// Required installing ratchet/pawl with a command below before running the code.
// composer require ratchet/pawl
require __DIR__ . '/vendor/autoload.php';
$loop = \React\EventLoop\Factory::create();
$reactConnector = new \React\Socket\Connector($loop);
$connector = new \Ratchet\Client\Connector($loop, $reactConnector);
$connector("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")->then(function (Ratchet\Client\WebSocket $conn) use ($connector, $loop) {
$conn->on('message', function (\Ratchet\RFC6455\Messaging\MessageInterface $msg) use ($conn) {
echo "{$msg}\n";
});
$conn->on('close', function ($code = null, $reason = null) {
echo "Connection closed ({$code} - {$reason})\n";
});
$conn->send('{ "command" : "subscribe", "channel" : "positionSummaryEvents", "option" : "PERIODIC" }');
}, function (\Exception $e) use ($loop) {
echo "Could not connect: {$e->getMessage()}\n";
$loop->stop();
});
$loop->run();
#![deny(warnings)]
extern crate tungstenite;
extern crate url;
use tungstenite::{connect, Message};
use url::Url;
fn main() {
position_events_ws();
}
fn position_events_ws() {
let (mut socket, _response) =
connect(Url::parse("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx").unwrap()).expect("Can't connect");
socket
.write_message(Message::Text("{ \"command\" : \"subscribe\", \"channel\": \"positionSummaryEvents\", \"option\": \"PERIODIC\" }".into()))
.unwrap();
loop {
let msg = socket.read_message().expect("Error reading message");
println!("{}", msg);
}
}
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Control.Concurrent (forkIO)
import Control.Monad (forever, unless)
import Control.Monad.Trans (liftIO)
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Network.Socket (withSocketsDo)
import qualified Network.WebSockets as WS
import qualified Wuss as WSS (runSecureClient)
app :: WS.ClientApp ()
app conn = do
putStrLn "Connected!"
WS.sendTextData conn ("{ \"command\" : \"subscribe\", \"channel\": \"positionSummaryEvents\", \"option\": \"PERIODIC\" }" :: Text)
_ <- forkIO $ forever $ do
msg <- WS.receiveData conn
liftIO $ T.putStrLn msg
let loop = do
line <- T.getLine
unless (T.null line) $ WS.sendTextData conn line >> loop
loop
WS.sendClose conn ("msgData" :: Text)
main :: IO ()
main = withSocketsDo $ WSS.runSecureClient "forex-api.coin.z.com" 443 "/ws/private/v1/xxxxxxxxxxxxxxxxxxxx" app
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
class Example
{
public static void Main(string[] args)
{
var task = PositionSummaryEvents();
task.Wait();
}
static async Task PositionSummaryEvents()
{
const string endpoint = "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx";
const string message = "{ \"command\" : \"subscribe\", \"channel\": \"positionSummaryEvents\" }";
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(endpoint), CancellationToken.None);
var messageBytes = Encoding.UTF8.GetBytes(message);
await client.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, true,
CancellationToken.None);
while (client.State == WebSocketState.Open)
{
var incomingData = new byte[1024];
var result = await client.ReceiveAsync(new ArraySegment<byte>(incomingData), CancellationToken.None);
Console.WriteLine(Encoding.UTF8.GetString(incomingData, 0, result.Count));
}
}
}
}
// WebSocket4Net example
using System;
using WebSocket4Net;
class Example
{
static WebSocket websocket;
static void Main(string[] args)
{
websocket = new WebSocket("wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx");
websocket.Opened += Websocket_Opened;
websocket.MessageReceived += Websocket_MessageReceived;
websocket.Open();
Console.Read();
}
private static void Websocket_Opened(object sender, EventArgs e)
{
const string message = "{ \"command\" : \"subscribe\", \"channel\": \"positionSummaryEvents\", \"option\": \"PERIODIC\" }";
websocket.Send(message);
}
private static void Websocket_MessageReceived(object sender, MessageReceivedEventArgs e)
{
Console.WriteLine(e.Message);
}
}
import Foundation
extension URLSessionWebSocketTask.Message {
var prettyPrintedJSONString: NSString? {
switch self {
case .string(let text):
guard let object = try? JSONSerialization.jsonObject(with: text.data(using: .utf8)!, options: []),
let data = try? JSONSerialization.data(withJSONObject: object, options: [.prettyPrinted]),
let prettyPrintedString = NSString(data: data, encoding: String.Encoding.utf8.rawValue) else { return nil }
return prettyPrintedString
default:
return nil
}
}
}
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
let url = URL(string: "wss://forex-api.coin.z.com/ws/private/v1/xxxxxxxxxxxxxxxxxxxx")!
let urlSession = URLSession(configuration: .default)
let webSocketTask = urlSession.webSocketTask(with: url)
webSocketTask.resume()
let message = URLSessionWebSocketTask.Message.string("""
{
"command": "subscribe",
"channel": "positionSummaryEvents",
"option":"PERIODIC"
}
""")
webSocketTask.send(message) { error in
if let error = error {
print(error)
}
}
webSocketTask.receive { result in
switch result {
case .failure(let error):
print(error)
case .success(let message):
print(message.prettyPrintedJSONString!)
dispatchGroup.leave()
}
}
dispatchGroup.notify(queue: .main) {
exit(EXIT_SUCCESS)
}
dispatchMain()
Response example:
{
"channel":"positionSummaryEvents",
"symbol":"USD_JPY",
"side":"BUY",
"averagePositionRate":"138.877",
"positionLossGain":"3644808.1",
"sumOrderedSize":"8000",
"sumPositionSize":"1821000",
"sumTotalSwap": "167407.6",
"timestamp":"2020-06-24T09:53:19.702Z",
"msgType":"PERIODIC"
}
Receives latest position summary events notifications.
After subscribe, latest position summary events notification will be sent.
Parameters
- Parameter type: JSON
| Property Name | Type | Required | Available Values |
|---|---|---|---|
| command | string | Required |
subscribe unsubscribe |
| channel | string | Required |
positionSummaryEvents |
| option | string | Optional | PERIODIC※If option is specified, it will send data every 5 seconds. ※If you request multiple subscriptions, only the latest request will be valid. |
Response
| Property Name | Value | Description |
|---|---|---|
| channel | string | positionSummaryEvents |
| symbol | string | The handling symbols are here |
| side | string | Side: BUY SELL |
| averagePositionRate | string | Average price of the position |
| positionLossGain | string | Settlement profit/loss |
| sumOrderedSize | string | Quantity of the order |
| sumPositionSize | string | Total quantity of the position |
| sumTotalSwap | string | Total swap |
| timestamp | string | Timestamp of the notifications |
| msgType | string | Message Type: INIT UPDATE PERIODIC |
- There is no Response when
unsubscribeis requested.
References
This section explains about codes, which are API parameters and response values.
Parameters
This section explains about parameters and their details.
symbol: Trading symbol
| Value | Description | Release date |
|---|---|---|
| USD_JPY | US Dollar/Japanese Yen | 2023/04/26 |
| EUR_JPY | Euro/Japanese Yen | 2023/04/26 |
| GBP_JPY | British Pound/Japanese Yen | 2023/04/26 |
| AUD_JPY | Australian Dollar/Japanese Yen | 2023/04/26 |
| NZD_JPY | New Zealand Dollar/Japanese Yen | 2023/04/26 |
| CAD_JPY | Canadian Dollar/Japanese Yen | 2023/04/26 |
| CHF_JPY | Swiss Franc/Japanese Yen | 2023/04/26 |
| TRY_JPY | Turkish Lira/Japanese Yen | 2023/08/05 |
| ZAR_JPY | South African Rand/Japanese Yen | 2023/08/05 |
| MXN_JPY | Mexican Peso/Japanese Yen | 2023/08/05 |
| EUR_USD | Euro/US Dollar | 2023/04/26 |
| GBP_USD | British Pound/US Dollar | 2023/04/26 |
| AUD_USD | Australian Dollar/US Dollar | 2023/04/26 |
| NZD_USD | New Zealand Dollar/US Dollar | 2023/04/26 |
side: Side
| Value | Description |
|---|---|
| BUY | Buy |
| SELL | Sell |
executionType: Execution Type
| Value | Description |
|---|---|
| MARKET | Market order |
| LIMIT | Limit order |
| STOP | Stop limit order |
HTTP Status Codes
Status Codes
| Status Code | Description |
|---|---|
| 0 | A response for successful API processing. |
Error Codes
| Error Code | Description |
|---|---|
| ERR-143 | Currently trade restriction. Cannot trade. |
| ERR-148 | The settlement size exceeds the new order size. |
| ERR-189 | The quantity of your close order exceeds your open position. |
| ERR-200 | There are existing active orders and your order exceeds the maximum quantity that can be ordered. Please change the quantity to order or cancel an active order in order to create a new close order. |
| ERR-201 | Insufficient funds. |
| ERR-254 | The specified position does not exist. |
| ERR-414 | Request positionID mismatched symbol. |
| ERR-423 | Exceeds settle quantity. |
| ERR-512 | Duplicate positionID settlement request. |
| ERR-542 | Cannot change non-OCO order. |
| ERR-595 | Cannot change non-IFO/IFD order. |
| ERR-635 | The number of active orders has exceeded the limit. Please cancel an active order to create a new order. |
| ERR-759 | Active contract count restriction. |
| ERR-760 | No prices are changed. |
| ERR-761 | The order price exceeds the price limit range. |
| ERR-769 | The specified order has expired. |
| ERR-786 | This clientOrderId is in use by your other active order. |
| ERR-5003 | The API usage limits are exceeded. |
| ERR-5008 | The API-TIMESTAMP set in the request header is later than the system time of the API. Please try updating the system time. |
| ERR-5009 | The API-TIMESTAMP set in the request header is earlier than the system time of the API. Please try updating the system time. |
| ERR-5010 | The API-SIGN (Signature) is invalid. Please check Authentication. |
| ERR-5011 | The API-KEY is empty. Please check Authentication. |
| ERR-5012 | The API authentication is invalid. |
| ERR-5014 | The membership agreement has not been completed. |
| ERR-5106 | The request parameter is invalid. |
| ERR-5114 | The number of decimals exceeds tick size. Please check tick size here. |
| ERR-5122 | The specified order can not be changed or canceled (already MODIFYING, CANCELLING, CANCELED, EXECUTED or EXPIRED). Orders can be changed or canceled only in ORDERED (WAITING for stop limit orders) status. |
| ERR-5123 | The specified order doesn't exist. |
| ERR-5125 | Returned when there is API restriction. |
| ERR-5126 | The amount exceeds the maximum order amount or is less than the minimum order amount. Please check the trading rules here. |
| ERR-5130 | The orderID(s) exceeds the number that can be specified. |
| ERR-5132 | The executionID(s) exceeds the number that can be specified. |
| ERR-5201 | A response code that when Public/Private API is called while the service is in a regular maintenance. |
| ERR-5202 | A response code that when Public/Private API is called while the service is in a emergency maintenance. |
| ERR-5204 | The request API PATH is invalid. |
| ERR-5206 | The limits of changing order for each order are exceeded. If you would like further changes for the order, please cancel the order and create a brand new order. |
| ERR-5207 | Invalid symbol, interval or date values. |
| ERR-5208 | OrderId(s) and executionId(s) cannot be used at the same time. |
| ERR-5209 | OrderId(s) and rootOrderId(s) cannot be used at the same time. |
| ERR-5210 | Invalid combination of executionType stopPrice limitPrice |
| ERR-5211 | LowerBound or UpperBound cannot be specified for side or executionType. |
| ERR-5213 | RootOrderId and ClientOrderId cannot be used at the same time. |
| ERR-5214 | Size must not be specified. |
| ERR-5218 | The order was rejected for trading close. |
| ERR-5219 | Cannot change non-normal order. |
| ERR-5220 | Set the secondPrice higher than the firstPrice. |
| ERR-5221 | Set the secondPrice lower than the firstPrice. |
| ERR-5222 | Set the secondLimitPrice higher than the firstPrice. |
| ERR-5223 | Set the secondLimitPrice lower than the firstPrice. |
| ERR-5224 | Set the secondStopPrice lower than the firstPrice. |
| ERR-5225 | Set the secondStopPrice higher than the firstPrice. |
| ERR-5226 | Please set the stop price higher than current price. |
| ERR-5227 | Please set the stop price lower than current price. |
| ERR-5228 | Please set the stop price lower than the limit price. |
| ERR-5229 | Please set the stop price higher than the limit price. |
Feedback
We'd like to hear some feedback about our API. Your feedback will be carefully reviewed by our development team, to be developed and released sequentially.
Please click here to contact us about any requests you may have about the API.
※Please click here to contact us about API inquiries. We may take some time to respond depending on the inquiry. Thank you for your understanding.
Changelog
2023
2023-12-16 New
The samples have been updated to correspond to the latest versions of each language as of December 16, 2023.
2023-10-28
Version v1 has been released.