-----BEGIN RSA PRIVATE KEY-----
MIICXgIBAAKBgQC33DHVHpT4IKLzLb59ZcxcmPvUsIO3+s8qd8aAM1le/DHVHmYi
Vp39af0dF+maQ+1NfikmVBfl7HfygCVLb/PtFrfM52zyXXurdM99Ijmgotit3S8X
C0jImrlyCR9TmrSNyN/IadfNby1wFN0jitka3Z7JuFw2ieY3PO2AGh7hewIDAQAB
AoGAUHZ8FIHKvgBCb9wgFm7bjdaht0X8jyKjUTmT1H0kao5CHLuuBO8VO1cMH5Rc
dlet3ZEN3ylEQCpJoAX2zFnVTLmsoH484ODCJkHxuMN0ONzPRiSeJSvgmHj7ko/L
D+19bWe4u0ru216w5Th0etGYNEsYw6BeTNDHK0571vvhjoECQQDno90GAqR6t4xQ
Bkvv2z67hIMPkrw8ahvD1b94jTlkK5pBCnQ4kBx8I0BbFSKOH1NDjpVFifwtOhqo
XDtC7f5BAkEAyzID8BzYar/9J02by6/PNVRxvwO51y6KMX6ZccDd80IeCKYX9Jnw
gUBwI83iLL8C3cF9sTQ9focj7enBO4wouwJBAJruVNTCS7Tws16K95t0Lx9I4Eg4
QsK9zdhMTQaanrpLF59NGLMEYKj/AvpoxnX8qbpT0a9zPUIazN2y4sg/WoECQQCJ
h9LOhFee+U+ZeJgIp3hyOjO6/ASfNqrmkS++pLIVYhz98Z2pO0Bj23+LXGDHtIl2
Gu6+MAOnTkTtVRgq+9TdAkEAqQYCvTifS07C1/9f7bd3EFv2UtCpBiugvLPeTzFK
pAbaXZeMX61rw69V1cVEM5jVBrVW0I66VMJIDlMtuwePrQ==
-----END RSA PRIVATE KEY-----

-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC33DHVHpT4IKLzLb59ZcxcmPvU
sIO3+s8qd8aAM1le/DHVHmYiVp39af0dF+maQ+1NfikmVBfl7HfygCVLb/PtFrfM
52zyXXurdM99Ijmgotit3S8XC0jImrlyCR9TmrSNyN/IadfNby1wFN0jitka3Z7J
uFw2ieY3PO2AGh7hewIDAQAB
-----END PUBLIC KEY-----

using System;
using System.IO;
using System.Net;
using System.Text;
using System.Text.Json;
using System.Security.Cryptography;

namespace seamless
{
    public class SendData
    {
        public string channel { get; set; }
        public string agent { get; set; }
        public string account { get; set; }
    }
    class Program
    {
        public static string api_url = "<url>"; // This is a example Url, please fill in the right Url from the MIF
        public static string channel = "00746280"; // This is a example Channel, please fill in the right Channel from the MIF
        public static string agent = "SeamlessEx01"; // This is a example Agent, please fill in the right Agent from the MIF
        public static byte[] HashAndSignBytes(byte[] DataToSign)
        {
            try
            {
                // Create a new instance of RSACryptoServiceProvider using the
                // key from RSAParameters.
                RSACryptoServiceProvider RSAalg = new RSACryptoServiceProvider(1024);
                using (var stream = File.OpenRead("example_private.pem")) // Please Change the example_private.pem to your rsaPrivateKey
                using (var reader = new PemUtils.PemReader(stream))
                {
                    var rsaParameters = reader.ReadRsaKey();
                    RSAalg.ImportParameters(rsaParameters);
                }
                // Hash and sign the data. Pass a new instance of SHA256
                // to specify the hashing algorithm.
                return RSAalg.SignData(DataToSign, SHA256.Create());
            }
            catch(CryptographicException e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }
        public static void CreateMember()
        {
            SendData _data = new SendData()
            {
                channel = channel, // this is a channel
                agent = agent, // this is a agent
                account = "example001" // This is a example Account, please fill in the right Account from the MIF
            };
            string Json = JsonSerializer.Serialize<SendData>(_data);
            var post_data = Encoding.UTF8.GetBytes(Json);
            var signedData = HashAndSignBytes(post_data);
            var Signature = Convert.ToBase64String(signedData);
            var request = (HttpWebRequest)WebRequest.Create("https://"+ api_url +"/v1/member/create");
            request.Method = "POST";
            request.ContentType = "application/json";
            request.Headers.Set("X-Ds-Signature", Signature);
            request.ContentLength = post_data.Length;
            using (var stream = request.GetRequestStream())
            {
                stream.Write(post_data, 0, post_data.Length);
            }
            var response = (HttpWebResponse)request.GetResponse();
            var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
            Console.WriteLine(responseString);
        }
        static void Main(string[] args)
        {
            CreateMember();
        }
    }
}

package main

import (
    "bytes"
    "crypto"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
    "crypto/x509"
    "encoding/base64"
    "encoding/json"
    "encoding/pem"
    "fmt"
    "io/ioutil"
    "net/http"
)

type CreateMemberRequest struct {
    Channel string `json:"channel"`
    Agent   string `json:"agent"`
    Account string `json:"account"`
}

func main() {
    apiDomain := "<url>" // This is a example Url, please fill in the right Url from the MIF

    rsaPrivateKey := getPrivateKey("./example_private.pem") // Please Change the example_private.pem to your rsaPrivateKey

    createMemberReq := CreateMemberRequest{
        Channel: "00746280", // This is a example Channel, please fill in the right Channel from the MIF
        Agent:   "SeamlessEx01", // This is a example Agent, please fill in the right Agent from the MIF
        Account: "example001", // This is a example Account, please fill in the right Account from the MIF
    }
    data, err := json.Marshal(&createMemberReq)
    if err != nil {
        panic(err)
    }
    signature, err := sign(rsaPrivateKey, data)
    if err != nil {
        panic("sing error, err: " + err.Error())
    }
    base64Signature := base64.StdEncoding.EncodeToString(signature)

    url := fmt.Sprintf("https://%s/v1/member/create", apiDomain)
    post(url, base64Signature, data)
}

func getPrivateKey(path string) *rsa.PrivateKey {
    privateBytes, err := ioutil.ReadFile(path)
    if err != nil {
        panic("read file error, err: " + err.Error())
    }

    block, _ := pem.Decode(privateBytes)
    if block == nil {
        panic("pem decode block nil")
    }

    switch block.Type {
    case "RSA PRIVATE KEY":
        rsaPrivateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
        if err != nil {
            panic("x509.ParsePKCS1PrivateKey error, err: " + err.Error())
        }
        return rsaPrivateKey
    default:
        panic("block type is not RSA PRIVATE KEY, type: " + block.Type)
    }

}

func sign(privateKey *rsa.PrivateKey, data []byte, ) ([]byte, error) {
    h := sha256.New()
    h.Write(data)
    d := h.Sum(nil)
    return rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, d)
}

func post(url, xDSSignature string, requestBody []byte) (statusCode int, body string) {
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(requestBody))
    req.Header.Set("X-Ds-Signature", xDSSignature)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    fmt.Println("response Status:", resp.Status)
    fmt.Println("response StatusCode:", resp.StatusCode)
    responseBody, _ := ioutil.ReadAll(resp.Body)
    fmt.Println("response Body:", string(responseBody))

    return resp.StatusCode ,string(responseBody)
}

package com.seamless;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.io.ObjectInputFilter.Status;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.io.File;
import java.nio.charset.Charset;
import java.util.Base64;
import java.nio.file.Files;
import java.security.Signature;
import org.bouncycastle.asn1.ASN1Sequence;
import org.bouncycastle.asn1.pkcs.RSAPrivateKeyStructure;
import java.security.spec.RSAPrivateKeySpec;
import java.security.KeyFactory;
import java.security.PrivateKey;
public class Seamless {
    public static final String api_url = "<url>"; // This is a example Url, please fill in the right Url from the MIF
    public static final String channel = "00746280"; // This is a example Channel, please fill in the right Channel from the MIF
    public static final String agent = "SeamlessEx01"; // This is a example Agent, please fill in the right Agent from the MIF
    // Please add your privateKey path
    public static final String PRV_PATH = "seamless/java/example_private.pem"; // Please Change the example_private.pem to your rsaPrivateKey
    public static String signSHA256RSA(String data) {
        try {
            File file = new File(PRV_PATH);
            String strPk = new String(Files.readAllBytes(file.toPath()), Charset.defaultCharset());
            String realPK = strPk.replaceAll("-----BEGIN RSA PRIVATE KEY-----", "")
            .replaceAll("-----END RSA PRIVATE KEY-----", "")
            .replaceAll("\n", "");
            byte[] b1 = Base64.getDecoder().decode(realPK);
            ASN1Sequence asn1Data = (ASN1Sequence) ASN1Sequence.fromByteArray(b1);
            RSAPrivateKeyStructure asn1PrivKey = new RSAPrivateKeyStructure(asn1Data);
            RSAPrivateKeySpec rsaPrivKeySpec = new RSAPrivateKeySpec(asn1PrivKey.getModulus(), asn1PrivKey.getPrivateExponent());
            KeyFactory kf = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = kf.generatePrivate(rsaPrivKeySpec);
            // sign with SHA256withRSA
            Signature privateSignature = Signature.getInstance("SHA256withRSA");
            privateSignature.initSign(privateKey);
            privateSignature.update(data.getBytes("UTF-8"));
            byte[] s = privateSignature.sign();
            byte[] SignatureData = Base64.getEncoder().encode(s);

            return new String(SignatureData);
        } catch (java.lang.Exception e) {
            System.out.println(e);
        }
        return "";
    }
    public static void createMember() {
        try{
            String data = "{\"agent\":\""+ agent +"\", \"channel\":\""+ channel +"\", \"account\":\"example001\"}"; // This is a example Account, please fill in the right Account from the MIF
            System.out.println(data);
            String SignatureData = signSHA256RSA(data);
            // Create connection
            URL url = new URL("https://"+ api_url +"/v1/member/create");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoOutput(true);
            connection.setDoInput(true);
            connection.setRequestMethod("POST");
            connection.setUseCaches(false);
            connection.setInstanceFollowRedirects(true);
            connection.setRequestProperty("Content-Type","application/json; charset=UTF-8");
            connection.setRequestProperty("X-Ds-Signature",SignatureData);
            connection.connect();

            // post request
            DataOutputStream out = new DataOutputStream(connection.getOutputStream());
            out.write(data.getBytes("UTF-8"));
            out.flush();
            out.close();

            BufferedReader reader = new BufferedReader(new InputStreamReader(
                    connection.getInputStream()));
            String lines;
            StringBuffer sb = new StringBuffer("");
            while ((lines = reader.readLine()) != null) {
                lines = new String(lines.getBytes(), "utf-8");
                sb.append(lines);
            }
            System.out.println(sb);
            reader.close();
            // close connection
            connection.disconnect();
        } catch (MalformedURLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        createMember();
    }
}

class EXAMPLE
{
    protected $api_url = "<url>"; // This is a example Url, please fill in the right Url from the MIF
    protected $channel = "00746280"; // This is a example Channel, please fill in the right Channel from the MIF
    protected $agent = "SeamlessEx01"; // This is a example Agent, please fill in the right Agent from the MIF
    protected $ds_sign = "";

    public function encrypt($data)
    {
        // import your private key
        $privateKeyId = openssl_pkey_get_private(file_get_contents('example_private.pem')); // Please Change to your rsaPrivateKey
        // sign data with your private key
        openssl_sign($data, $signature, $privateKeyId, 'RSA-SHA256');
        // encode into base64
        $ds_sign = base64_encode($signature);
        $this->ds_sign = $ds_sign;
        // you may free up memory after, but I wouldn't recommend, since you are going to make many requests and sign each of them.
        // importing key from file each time isn't brightest idea
        openssl_free_key($privateKeyId);

        echo "signature: \n" . $ds_sign . "\n";

        return $ds_sign;
    }
    public function decrypt($data)
    {
        // importing public key
        $ds_pub_key = openssl_pkey_get_public(file_get_contents('example_public.pub')); // Please Change to your rsaPublicKey
        // verifying signature for $data and imported public key
        // note that signature firstly was decoded from base64
        $valid = openssl_verify($data, base64_decode($this->ds_sign), $ds_pub_key, 'RSA-SHA256');
        if ($valid == 1){
            echo "signature is valid \n";
        } else {
            echo "signature is NOT valid\n";
        }
        // same thing about freeing of key
        openssl_free_key($ds_pub_key);
    }
    public function CreateMember()
    {
        $data = [
            "channel" => $this->channel, // This is a Channel
            "agent" => $this->agent, // This is a Agent
            "account" => "example001", // This is a example Account, please fill in the right Account from the MIF
        ];
        $content = json_encode($data);
        $signature = $this->encrypt($content);
        $header = [
            'Content-type: application/json',
            'X-Ds-Signature: '.$signature,
        ];

        $curl = curl_init("https://".$this->api_url."/v1/member/create");
        curl_setopt($curl, CURLOPT_HEADER, false);
        curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($curl, CURLOPT_HTTPHEADER, $header);
        curl_setopt($curl, CURLOPT_POST, true);
        curl_setopt($curl, CURLOPT_POSTFIELDS, $content);
        $json_response = curl_exec($curl);

        $status = curl_getinfo($curl, CURLINFO_HTTP_CODE);
        if ( $status != 200 ) {
            die("Error: failed with status $status, response $json_response, curl_error " . curl_error($curl) . ", curl_errno " . curl_errno($curl));
        }

        curl_close($curl);

        $response = json_decode($json_response, true);
        print_r($response);
    }
}

$example = new EXAMPLE();
$example->CreateMember();

import json
import requests
from Crypto.Hash import SHA256
from Crypto.Signature import PKCS1_v1_5
from Crypto.PublicKey import RSA
import base64

api_url = 'https://<url>/' # This is a example Url, please fill in the right Url from the MIF
api = 'v1/member/create'
example_agent = "SeamlessEx01" # This is a example Agent, please fill in the right Agent from the MIF
example_channel = "00746280" # This is a example Channel, please fill in the right Channel from the MIF
example_account = "example001" # This is a example Account, please fill in the right Account from the MIF


def SignData(d, f):
    digest = SHA256.new()
    digest.update(d.encode())
    private_key = open(f, 'rb').read()
    prkey = RSA.importKey(private_key)
    signer = PKCS1_v1_5.new(prkey)
    sig = signer.sign(digest)
    return base64.b64encode(sig)

def VerifyData(d, s, f):
    digest = SHA256.new()
    digest.update(d.encode())
    public_key = open(f, 'rb').read()
    pbkey = RSA.importKey(public_key)
    signer = PKCS1_v1_5.new(pbkey)
    return signer.verify(digest, s)


def SignAndVerify():
    data = {"channel": example_channel ,"agent": example_agent, "account": example_account}
    print ("Sign: ", SignData(json.dumps(data), "example_private.pem")) # Please Change the example_private.pem to your rsaPrivateKey
    print ("Verify result: ", VerifyData(json.dumps(data), base64.b64decode(SignData(json.dumps(data), "example_private.pem")), "example_public.pub")) # Please Change the example_private.pem to your rsaPrivateKey, and change the example_public.pub to your rsaPublicKey


def CreateMember():
    data = {"channel": example_channel ,"agent": example_agent, "account": example_account}
    headers = {
        'content-type': "application/json",
        'X-Ds-Signature': SignData(json.dumps(data), "example_private.pem") # Please Change the example_private.pem to your rsaPrivateKey
    }
    resp = requests.request("POST", api_url + api, headers=headers, json=json.loads(json.dumps(data)))
    print (resp.text)

SignAndVerify()
CreateMember()

// nodejs example

const request = require("request").defaults({});
var crypto = require("crypto");
var fs = require("fs");

const api_url = "<url>"; // This is a example Url, please fill in the right Url from the MIF
const channel = "00746280"; // This is a example Channel, please fill in the right Channel from the MIF
const agent = "SeamlessEx01"; // This is a example Agent, please fill in the right Agent from the MIF

function CreateMember() {
  const data = {
    channel: channel, // This is a Channel
    agent: agent, // This is a Agent
    account: "example001", // This is a example Account, please fill in the right Account from the MIF
  };
  var dataString = JSON.stringify(data);
  return new Promise((done) => {
    fs.readFile("example_private.pem", function (err, privateKey) {
      // Please Change the example_private.pem to your rsaPrivateKey
      var signerObject = crypto.createSign("RSA-SHA256");
      signerObject.update(dataString);
      var signature = signerObject.sign({ key: privateKey }, "base64");
      var sendData = JSON.parse(dataString);
      var options = {
        url: "https://" + api_url + "/v1/member/create",
        headers: {
          "X-Ds-Signature": signature,
        },
        method: "Post",
        json: sendData,
      };
      request(options, (err, res, body) => {
        console.log(body);
      });
    });
  });
}

CreateMember();

POST /v1/member/create HTTP/1.1
Content-Type: application/json
X-Ds-Signature: QNng1bL9YEXE5yLH6MSCuZ9u34GC3ACrt/EeCltCKGDxwQp3EF/IwpdUlVf/h+DFanLzCirFygiRkwFP09yNHCg6DpZZUc+c0mEmPF7r6xu4Zx4BcRKmBe6hBxUVFHtIdnmvXwuEf5xKAa2/pa0+udyQ+z/YJ14FZcNb8iEfLUI=

{"agent":"agent01","account":"player001","token":"1ceda4754e7e413592a6450fb224165f"}

{
  "agent": "agent01",
  "account": "player001",
  "token": "e278a9ea38da42dd9b84148c2f99a031",
  "amount": 0,
  "game_id": "100",
  "owner_account": "owner01"
}

{
  "balance": 99999.1,
  "status": 1
}

{
  "trans_id": "6475bec9b187af9ab5884e30",
  "agent": "agent01",
  "account": "player001",
  "game_id": "1001",
  "owner_account": "owner01",
  "token": "88406af3628342f19cea6042d0cb2267",
  "bet_amount": 10,
  "payout_amount": 20,
  "valid_amount": 10,
  "feature_buy": "FG1:2",
  "bet_id": "65ea8c1554e79819302d68e5"
}

{
  "trans_id": "6475bec9b187af9ab5884e30",
  "balance": 4000,
  "status": 1
}

{
  "trans_id": "6475bec9b187af9ab5884e30",
  "amount": 8000,
  "agent": "agent01",
  "account": "player001",
  "token": "88406af3628342f19cea6042d0cb2267",
  "game_id": "1001",
  "owner_account": "owner01"
}

{
  "trans_id": "6475bec9b187af9ab5884e30",
  "balance": 4000,
  "status": 1
}

{
  "trans_id": "6475bec9b187af9ab5884e30",
  "amount": 8000,
  "agent": "agent01",
  "account": "player001",
  "game_id": "1001",
  "owner_account": "owner01",
  "token": "88406af3628342f19cea6042d0cb2267",
  "valid_amount": 10,
  "feature_buy": "FG1:2",
  "bet_id": "65ea8c1554e79819302d68e5"
}

{
  "trans_id": "6475bec9b187af9ab5884e30",
  "balance": 4000,
  "status": 1
}

{
  "trans_id": "6475bec9b187af9ab5884e30",
  "amount": 8000,
  "agent": "agent01",
  "account": "player001",
  "game_id": "1001"
}

{
  "trans_id": "6475bec9b187af9ab5884e30",
  "balance": 4000,
  "status": 1
}

{
  "channel": "53346874",
  "agent": "agent01",
  "account": "player001"
}

{
  "result": {
    "code": 1,
    "msg": "success"
  }
}

{
  "channel": "91213456",
  "game_id": "1001",
  "lang": "zh_cn",
  "is_demo": true
}

{
  "result": {
    "code": 1,
    "msg": "success"
  },
  "url": "https://game_server_url/h5/1001/?token=d01e14944dcd4a0e9e207f4438bb37da&lang=zh_cn&oper=ds&backurl=https://backurl.com"
}

{
  "result": {
    "code": 1,
    "msg": "UNDER MAINTENANCE"
  },
  "static": "",
  "dynamic": "",
  "token": "",
  "url": "https://www.dragoonsoft.com/maintenace.html"
}

{
  "channel": "53346874",
  "agent": "AG000001",
  "account": "Username002"
}

{
  "result": {
    "code": 1,
    "msg": "success"
  }
}

{
  "channel": "53346874",
  "agent": "AG000001",
  "account": "Username002"
}

{
  "result": {
    "code": 1,
    "msg": "SUCCESS"
  },
  "login_info": {
    "online": 2
  }
}

{
  "channel": "53346874",
  "agent": "AG000001"
}

{
  "result": {
    "code": 1,
    "msg": "SUCCESS"
  },
  "list": [
    {
      "agent": "game01",
      "account": "Username002",
      "game_id": "0000",
      "login_time": "2020-11-05T08:14:37.929977473Z"
    }
  ]
}

{
  "channel": "53346874",
  "finish_time": {
    "start_time": "2018-10-19T08:54:14+01:00",
    "end_time": "2018-10-20T11:47:08+01:00"
  },
  "index": 0,
  "limit": 10
}

{
  "result": {
    "code": 1,
    "msg": "success",
    "timestamp": "2018-11-12T04:03:53.174604283Z"
  },
  "total": "8870",
  "rows": [
    {
      "id": "1",
      "bet_at": "2018-10-18T05:47:51Z",
      "finish_at": "2018-10-18T05:47:51Z",
      "agent": "AG0000001",
      "member": "MB03",
      "game_id": "1001",
      "game_serial": "4604283",
      "game_type": 1,
      "round_id": "1",
      "bet_amount": "1200",
      "payout_amount": "0",
      "valid_amount": "1200",
      "status": 1,
      "fee_amount": "10",
      "jp_amount": "10",
      "event_id": "",
      "event_amount": 0,
      "feature_buy": ""
    },
    {
      "id": "2",
      "bet_at": "2018-10-18T05:47:51Z",
      "finish_at": "2018-10-18T05:47:51Z",
      "agent": "AG0000001",
      "member": "MB03",
      "game_id": "1001",
      "game_serial": "38427123",
      "game_type": 1,
      "round_id": "1",
      "bet_amount": "3600",
      "payout_amount": "0",
      "valid_amount": "3600",
      "status": 1,
      "fee_amount": "10",
      "jp_amount": "10",
      "event_id": "",
      "event_amount": 0,
      "feature_buy": "FG1:2"
    }
  ]
}

{
  "channel": "53346874",
  "game_id": "2001",
  "game_serial": "23134242",
  "lang": "zh_cn",
  "session_id": "1001_iEZYLBHs3I8yDAnR:5f3db5dd96009684de9e22e3_5f3dbd055839025095efa8be"
}

{
  "result": {
    "code": 1,
    "msg": "success"
  },
  "url": "https://<record.page>/bet_detail/?token=3fd0e97e-198b-4d34-9ab0-cd3f82f79ba3&lang=zh_cn"
}

{
  "channel": "53346874",
  "agent": "AG0000001",
  "account": "MB03",
  "game_id": "2001",
  "lang": "zh_cn"
}

{
  "result": {
    "code": 1,
    "msg": "success"
  },
  "url": "https://<record.page>/auth/eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0IjoiODc3MjZjOTg3M2NlNGRmNWI4YTM4MTdiZTc2YjU5NTQifQ.qzLt51idNxxsZV4nXfO0wui-moVDeRdolhlNNdZp7go?g=1&gid=1001&lang=en_us"
}

{
  "channel": "53346874",
  "start_time": "2018-10-19T13:00:00+01:00",
  "end_time": "2018-10-19T13:59:59+01:00",
  "index": 0,
  "limit": 10
}

{
  "result": {
    "code": 1,
    "msg": "success"
  },
  "rows": [
    {
      "statistics_date": "2018-10-19T13:00:00+01:00",
      "bet_count": 0,
      "bet_amount": 0,
      "real_bet_amount": 0,
      "payout_amount": 0,
      "valid_amount": 0,
      "fee_amount": 0,
      "jp_amount": 0,
      "win_loss_amount": 0
    }
  ]
}

{
  "channel": "53346874",
  "finish_time": {
    "start_time": "2018-10-19T08:54:14+01:00",
    "end_time": "2018-10-19T08:57:08+01:00"
  }
}

{
  "result": {
    "code": 1,
    "msg": "SUCCESS"
  },
  "rows": [
    {
      "agent": "cstest00",
      "bet_count": "246",
      "bet_amount": 9541.8,
      "payout_amount": 9472.12,
      "valid_amount": 9541.8,
      "fee_amount": 0,
      "jp_amount": 0
    }
  ]
}

{
  "channel": "53346874"
}

{
  "result": {
    "code": 1,
    "msg": "SUCCESS"
  },
  "game_info_state_list": [
    {
      "id": "1001",
      "type": "1",
      "active": true,
      "names": {
        "en_us": "Ocean Lord",
        "th_th": "จ้าวมหาสมุทร",
        "vi_vn": "Chúa tể đại dương",
        "zh_cn": "海霸王"
      },
      "latest": false,
      "hot": true,
      "weight": "3002"
    },
    {
      "id": "1002",
      "type": "1",
      "active": true,
      "names": {
        "en_us": "Let's Shoot",
        "th_th": "มายิงกัน",
        "vi_vn": "Hãy Bắn",
        "zh_cn": "吃我一炮"
      },
      "latest": false,
      "hot": true,
      "weight": "3003"
    }
  ]
}