GET https://openapi.fameex.com/sapi/v1/time

// Headers
Content-Type:application/json

curl -X GET "https://openapi.fameex.com/sapi/v1/time"

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;

public class Main {
  public static void main(String[] args) {
    try {
      // Create URL using URI
      URI uri = new URI("https://openapi.fameex.com/sapi/v1/time");
      HttpURLConnection conn = (HttpURLConnection) uri.toURL().openConnection();
      conn.setRequestMethod("GET");
      conn.setRequestProperty("User-Agent", "Java-Client");

      // Read response
      BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
      StringBuilder response = new StringBuilder();
      String line;
      while ((line = reader.readLine()) != null) {
        response.append(line);
      }
      reader.close();

      // Output result
      System.out.println("Response: " + response.toString());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://openapi.fameex.com/sapi/v1/time"

    // Send GET request
    resp, err := http.Get(url)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    // Read response body
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Failed to read response:", err)
        return
    }

    // Print response
    fmt.Println("Server returned:", string(body))
}

import requests

url = "https://openapi.fameex.com/sapi/v1/time"

try:
    response = requests.get(url)
    response.raise_for_status()  # Check if the request was successful
    print("Response:", response.text)
except requests.exceptions.RequestException as e:
    print("Request error:", e)

<?
$url = "https://openapi.fameex.com/sapi/v1/time";

// Initialize cURL
$ch = curl_init();

// Set cURL options
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); // Skip SSL certificate verification (if API requires)

// Execute request
$response = curl_exec($ch);

// Check for errors
if (curl_errno($ch)) {
    echo "cURL error：" . curl_error($ch);
} else {
    echo "Response: " . $response;
}

// Close cURL
curl_close($ch);

const https = require('https');

const url = 'https://openapi.fameex.com/sapi/v1/time';

https.get(url, (res) => {
  let data = '';

  // A chunk of data has been received.
  res.on('data', (chunk) => {
    data += chunk;
  });

  // The whole response has been received.
  res.on('end', () => {
    console.log("Response:", data);
  });

}).on('error', (err) => {
  console.log('Request error:', err.message);
});

{
    "timezone": "China Standard Time",
    "serverTime": 1705039779880
}

GET https://openapi.fameex.com/sapi/v1/order?orderId=12&symbol=ethusdt

// Headers Configuration
Content-Type: application/json
X-CH-TS: 1739503617552
X-CH-APIKEY: your API-KEY
X-CH-SIGN: 325b02a8444da041c71fb6e3c35c6baf87e5cb48acc19e4cd312b8bf821bfc1b

#!/bin/bash

# Set API information
API_URL="https://openapi.fameex.com"
REQUEST_URL="/sapi/v1/order"
QUERY_STRING="?orderId=12&symbol=ethusdt"

# Calculate the full request path
REQUEST_PATH="${REQUEST_URL}${QUERY_STRING}"
FULL_URL="${API_URL}${REQUEST_PATH}"

# API authentication information
API_KEY="your API-KEY"
API_SECRET="your API-SECRET"

# Generate current millisecond timestamp
timestamp=$(date +%s | awk '{print $1 * 1000}')

# Define request method
METHOD="GET"

# Generate signature (X-CH-SIGN) - GET request has no body
SIGN_PAYLOAD="${timestamp}${METHOD}${REQUEST_PATH}"
SIGNATURE=$(echo -n "$SIGN_PAYLOAD" | openssl dgst -sha256 -hmac "$API_SECRET" | awk '{print $2}')

# **Print debug information**
echo "==== Request Information ===="
echo "Timestamp (X-CH-TS): $timestamp"
echo "Sign Payload (string to be signed): $SIGN_PAYLOAD"
echo "Signature (X-CH-SIGN): $SIGNATURE"
echo "Request URL: ${FULL_URL}"
echo "=================="

# Send GET request
curl -X GET "$FULL_URL" \
    -H "X-CH-SIGN: $SIGNATURE" \
    -H "X-CH-APIKEY: $API_KEY" \
    -H "X-CH-TS: $timestamp" \
    -H "Content-Type: application/json"

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.Scanner;

public class FameexApiRequest {
    public static void main(String[] args) {
        try {
            // API information
            String apiUrl = "https://openapi.fameex.com";
            String requestUrl = "/sapi/v1/order";
            String queryString = "?orderId=12&symbol=ethusdt";

            // Calculate the full request path
            String requestPath = requestUrl + queryString;
            String fullUrl = apiUrl + requestPath;

            // API authentication information
            String apiKey = "your API-KEY";
            String apiSecret = "your API-SECRET";

            // Generate current millisecond timestamp
            String timestamp = String.valueOf(Instant.now().toEpochMilli());

            // Request method
            String method = "GET";

            // Generate signature (X-CH-SIGN) - GET request has no body
            String signPayload = timestamp + method + requestPath;
            String signature = hmacSha256(signPayload, apiSecret);

            // **Print debug information**
            System.out.println("==== Request Information ====");
            System.out.println("Timestamp (X-CH-TS): " + timestamp);
            System.out.println("Sign Payload (string to be signed): " + signPayload);
            System.out.println("Signature (X-CH-SIGN): " + signature);
            System.out.println("Request URL: " + fullUrl);
            System.out.println("==================");

            // Send GET request
            sendGetRequest(fullUrl, apiKey, timestamp, signature);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // HMAC-SHA256 signature calculation
    public static String hmacSha256(String data, String secret) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKeySpec = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
        mac.init(secretKeySpec);
        byte[] hash = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));

        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }

    // Send HTTP GET request
    public static void sendGetRequest(String fullUrl, String apiKey, String timestamp, String signature) {
        try {
            URL url = new URL(fullUrl);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");

            // Set request headers
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("X-CH-SIGN", signature);
            conn.setRequestProperty("X-CH-APIKEY", apiKey);
            conn.setRequestProperty("X-CH-TS", timestamp);

            // Send request and get response
            int responseCode = conn.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            Scanner scanner = new Scanner(conn.getInputStream(), StandardCharsets.UTF_8.name());
            while (scanner.hasNextLine()) {
                System.out.println(scanner.nextLine());
            }
            scanner.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io/ioutil"
    "net/http"
    "strconv"
    "time"
)

func main() {
    // API information
    apiURL := "https://openapi.fameex.com"
    requestURL := "/sapi/v1/order"
    queryString := "?orderId=12&symbol=ethusdt"

    // Calculate the full request path
    requestPath := requestURL + queryString
    fullURL := apiURL + requestPath

    // API authentication information
    apiKey := "your API-KEY"
    apiSecret := "your API-SECRET"

    // Generate current millisecond timestamp
    timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)

    // Request method
    method := "GET"

    // Generate signature (X-CH-SIGN) - GET request has no body
    signPayload := timestamp + method + requestPath
    signature := hmacSHA256(signPayload, apiSecret)

    // **Print debug information**
    fmt.Println("==== Request Information ====")
    fmt.Println("Timestamp (X-CH-TS):", timestamp)
    fmt.Println("Sign Payload (string to be signed):", signPayload)
    fmt.Println("Signature (X-CH-SIGN):", signature)
    fmt.Println("Request URL:", fullURL)
    fmt.Println("==================")

    // Send GET request
    sendGetRequest(fullURL, apiKey, timestamp, signature)
}

// Calculate HMAC-SHA256 signature
func hmacSHA256(data, secret string) string {
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(data))
    return hex.EncodeToString(h.Sum(nil))
}

// Send HTTP GET request
func sendGetRequest(fullURL, apiKey, timestamp, signature string) {
    client := &http.Client{}

    // Create a request
    req, err := http.NewRequest("GET", fullURL, nil)
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    // Settings Headers
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-CH-SIGN", signature)
    req.Header.Set("X-CH-APIKEY", apiKey)
    req.Header.Set("X-CH-TS", timestamp)

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

    // Read the response
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println("Response Code:", resp.StatusCode)
    fmt.Println("Response Body:", string(body))
}

import time
import hmac
import hashlib
import requests

# API Related information
API_URL = "https://openapi.fameex.com"
REQUEST_URL = "/sapi/v1/order"
QUERY_STRING = "?orderId=12&symbol=ethusdt"

# Calculate the complete request path
REQUEST_PATH = REQUEST_URL + QUERY_STRING
FULL_URL = API_URL + REQUEST_PATH

# API authentication information
API_KEY = "your API-KEY"
API_SECRET = "your API-SECRET"

# Generate the current millisecond-level timestamp
timestamp = str(int(time.time() * 1000))

# Request method
METHOD = "GET"

# Generate signature (X-CH-SIGN) - GET Request without body
SIGN_PAYLOAD = timestamp + METHOD + REQUEST_PATH
SIGNATURE = hmac.new(API_SECRET.encode(), SIGN_PAYLOAD.encode(), hashlib.sha256).hexdigest()

# **Print debugging information**
print("==== Request information ====")
print("Timestamp (X-CH-TS):", timestamp)
print("Sign Payload (String to be signed):", SIGN_PAYLOAD)
print("Signature (X-CH-SIGN):", SIGNATURE)
print("Request URL:", FULL_URL)
print("==================")

# Send GET request
headers = {
    "X-CH-SIGN": SIGNATURE,
    "X-CH-APIKEY": API_KEY,
    "X-CH-TS": timestamp,
    "Content-Type": "application/json"
}

response = requests.get(FULL_URL, headers=headers)

# Print the response
print("Response Code:", response.status_code)
print("Response Body:", response.text)

<?

// API related information
$API_URL = "https://openapi.fameex.com";
$REQUEST_URL = "/sapi/v1/order";
$QUERY_STRING = "?orderId=12&symbol=ethusdt";

// Calculate the complete request path
$REQUEST_PATH = $REQUEST_URL . $QUERY_STRING;
$FULL_URL = $API_URL . $REQUEST_PATH;

// API authentication information
$API_KEY = "your API-KEY";
$API_SECRET = "your API-SECRET";

// Generate the current millisecond-level timestamp
$timestamp = round(microtime(true) * 1000);

// Request method
$METHOD = "GET";

// Generate signature (X-CH-SIGN) - GET Request without body
$SIGN_PAYLOAD = $timestamp . $METHOD . $REQUEST_PATH;
$SIGNATURE = hash_hmac('sha256', $SIGN_PAYLOAD, $API_SECRET);

// **Print debugging information**
echo "==== Request information ====\n";
echo "Timestamp (X-CH-TS): " . $timestamp . "\n";
echo "Sign Payload (String to be signed): " . $SIGN_PAYLOAD . "\n";
echo "Signature (X-CH-SIGN): " . $SIGNATURE . "\n";
echo "Request URL: " . $FULL_URL . "\n";
echo "==================\n";

// Send GET request
$headers = [
    "Content-Type: application/json",
    "X-CH-SIGN: $SIGNATURE",
    "X-CH-APIKEY: $API_KEY",
    "X-CH-TS: $timestamp"
];

// Use cURL to send a GET request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $FULL_URL);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

// Execute the request and get the response
$response = curl_exec($ch);
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

// Print the response
echo "Response Code: $http_code\n";
echo "Response Body: $response\n";

?>

const axios = require("axios");
const crypto = require("crypto");

// API related information
const API_URL = "https://openapi.fameex.com";
const REQUEST_URL = "/sapi/v1/order";
const QUERY_STRING = "?orderId=12&symbol=ethusdt";

// Calculate the complete request URL
const REQUEST_PATH = REQUEST_URL + QUERY_STRING;
const FULL_URL = API_URL + REQUEST_PATH;

// API authentication information
const API_KEY = "your API-KEY";
const API_SECRET = "your API-SECRET";

// Generate the current millisecond-level timestamp
const timestamp = Date.now().toString();

// Request method
const METHOD = "GET";

// Generate signature (X-CH-SIGN) - GET requests have no body
const SIGN_PAYLOAD = timestamp + METHOD + REQUEST_PATH;
const SIGNATURE = crypto
  .createHmac("sha256", API_SECRET)
  .update(SIGN_PAYLOAD)
  .digest("hex");

// **Print debug information**
console.log("==== Request information ====");
console.log("Timestamp (X-CH-TS):", timestamp);
console.log("Sign Payload (String to be signed):", SIGN_PAYLOAD);
console.log("Signature (X-CH-SIGN):", SIGNATURE);
console.log("Request URL:", FULL_URL);
console.log("==================");

// Send GET request
const headers = {
  "Content-Type": "application/json",
  "X-CH-SIGN": SIGNATURE,
  "X-CH-APIKEY": API_KEY,
  "X-CH-TS": timestamp,
};

axios
  .get(FULL_URL, { headers })
  .then((response) => {
    console.log("Response Code:", response.status);
    console.log("Response Body:", response.data);
  })
  .catch((error) => {
    console.error("Error:", error.response ? error.response.data : error.message);
  });

// Switch to Node.js to view 『JavaScript code (categorized under HTTP)』

# Generate Signature (X-CH-SIGN) - GET Requests Have No Body
SIGN_PAYLOAD="${timestamp}${METHOD}${REQUEST_PATH}"
SIGNATURE=$(echo -n "$SIGN_PAYLOAD" | openssl dgst -sha256 -hmac "$API_SECRET" | awk '{print $2}')

// HMAC-SHA256 Signature Calculation
public static String hmacSha256(String data, String secret) throws Exception {
    Mac mac = Mac.getInstance("HmacSHA256");
    SecretKeySpec secretKeySpec = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
    mac.init(secretKeySpec);
    byte[] hash = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));

    StringBuilder hexString = new StringBuilder();
    for (byte b : hash) {
        String hex = Integer.toHexString(0xff & b);
        if (hex.length() == 1) {
            hexString.append('0');
        }
        hexString.append(hex);
    }
    return hexString.toString();
}

// Calculate HMAC-SHA256 Signature
func hmacSHA256(data, secret string) string {
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(data))
    return hex.EncodeToString(h.Sum(nil))
}

# Generate Signature (X-CH-SIGN) - GET Requests Have No Body
SIGN_PAYLOAD = timestamp + METHOD + REQUEST_PATH
SIGNATURE = hmac.new(API_SECRET.encode(), SIGN_PAYLOAD.encode(), hashlib.sha256).hexdigest()

// Generate Signature (X-CH-SIGN) - GET request has no body
$SIGN_PAYLOAD = $timestamp . $METHOD . $REQUEST_PATH;
$SIGNATURE = hash_hmac('sha256', $SIGN_PAYLOAD, $API_SECRET);

// Generate Signature (X-CH-SIGN) - GET request has no body
const SIGN_PAYLOAD = timestamp + METHOD + REQUEST_PATH;
const SIGNATURE = crypto
  .createHmac("sha256", API_SECRET)
  .update(SIGN_PAYLOAD)
  .digest("hex");

// JavaScript code (categorized under HTTP)

let secretKey = pm.environment.get("SecretKey");  // Retrieve API key from environment variables
let timestampString = String(Date.now()); // Generate timestamp (accurate to milliseconds)
let method = pm.request.method; // Get request method (GET, POST, etc.)

let fullUrl = pm.request.url.toString();
let requestPath = "/"+fullUrl.split("/").slice(3).join("/"); // Get the part after `example.com`

// The X-CH-SIGN request header is composed of the string:timestamp + method + requestPath + body (where + represents string concatenation)
// The `body` is the string representation of the request payload (POST only). If it is a GET request, the `body` can be omitted.
let signPayload = timestampString + method.toUpperCase() + requestPath;
if (method.toUpperCase() === "POST") {
    let body = pm.request.body ? pm.request.body.raw : null; // Get the request body (if present)
    if (body) {
        try {
            const parsedBody = JSON.parse(body); // Attempt to parse JSON
            let bodyString = JSON.stringify(parsedBody);
            signPayload += bodyString
        } catch (e) {
            signPayload += body; // If not JSON, directly append the raw body
        }
    } else {
        console.log("POST method failed to process body data");
    }
}

//The signature uses the HMAC-SHA256 algorithm, with the API-Secret corresponding to the API-KEY as the HMAC-SHA256 key.
const crypto = require('crypto-js'); // Load the CryptoJS library.
// Calculate the signature
let signature = crypto.HmacSHA256(signPayload, secretKey).toString(crypto.enc.Hex);

// Set Headers
pm.variables.set('xChTs', timestampString);
pm.variables.set('xChSign', signature);

{}

POST https://openapi.fameex.com/sapi/v1/order/test

// Headers Set up
Content-Type: application/json
X-CH-TS: 1739503617552
X-CH-APIKEY: your API-KEY
X-CH-SIGN: 325b02a8444da041c71fb6e3c35c6baf87e5cb48acc19e4cd312b8bf821bfc1b

#!/bin/bash

# Set API-related information
URL="https://openapi.fameex.com"
REQUEST_PATH="/sapi/v1/order/test"
API_URL="${URL}${REQUEST_PATH}"
API_KEY="your API-KEY"
API_SECRET="your API-SECRET"

# Generate the current millisecond-level timestamp
timestamp=$(date +%s | awk '{print $1 * 1000}')

# Define the request method
METHOD="POST"

# Define the request body (JSON format)
BODY_JSON='{"symbol":"BTCUSDT","price":"9300","volume":"1","side":"BUY","type":"LIMIT"}'

# Generate signature (X-CH-SIGN)
SIGN_PAYLOAD="${timestamp}${METHOD}${REQUEST_PATH}${BODY_JSON}"
SIGNATURE=$(echo -n "$SIGN_PAYLOAD" | openssl dgst -sha256 -hmac "$API_SECRET" | awk '{print $2}')

# **Print debug information**
echo "==== Request information ===="
echo "Timestamp (X-CH-TS): $timestamp"
echo "Sign Payload (String to be signed): $SIGN_PAYLOAD"
echo "Signature (X-CH-SIGN): $SIGNATURE"
echo "Request Body: $BODY_JSON"
echo "=================="

# Send request
curl -X POST "$API_URL" \
    -H "X-CH-SIGN: $SIGNATURE" \
    -H "X-CH-APIKEY: $API_KEY" \
    -H "X-CH-TS: $timestamp" \
    -H "Content-Type: application/json" \
    -d "$BODY_JSON"

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
import java.io.OutputStream;
import java.time.Instant;
import java.util.Base64;

public class FameexApiRequest {
    public static void main(String[] args) {
        try {
            // API Relevant information
            String url = "https://openapi.fameex.com";
            String requestPath = "/sapi/v1/order/test";
            String apiUrl = url + requestPath;
            String apiKey = "your API-KEY";
            String apiSecret = "your API-SECRET";

            // Get the current millisecond-level timestamp
            String timestamp = String.valueOf(Instant.now().toEpochMilli());

            // Request method
            String method = "POST";

            // Define the request body (JSON format)
            String bodyJson = "{\"symbol\":\"BTCUSDT\",\"price\":\"9300\",\"volume\":\"1\",\"side\":\"BUY\",\"type\":\"LIMIT\"}";

            // Generate signature (X-CH-SIGN)
            String signPayload = timestamp + method + requestPath + bodyJson;
            String signature = hmacSha256(signPayload, apiSecret);

            // **Print debug information**
            System.out.println("==== Request information ====");
            System.out.println("Timestamp (X-CH-TS): " + timestamp);
            System.out.println("Sign Payload (String to be signed): " + signPayload);
            System.out.println("Signature (X-CH-SIGN): " + signature);
            System.out.println("Request Body: " + bodyJson);
            System.out.println("==================");

            // Send request
            sendPostRequest(apiUrl, apiKey, timestamp, signature, bodyJson);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // HMAC-SHA256 Signature calculation
    public static String hmacSha256(String data, String secret) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKeySpec = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
        mac.init(secretKeySpec);
        byte[] hash = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }

    // Send HTTP POST request
    public static void sendPostRequest(String apiUrl, String apiKey, String timestamp, String signature, String bodyJson) {
        try {
            URL url = new URL(apiUrl);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("X-CH-SIGN", signature);
            conn.setRequestProperty("X-CH-APIKEY", apiKey);
            conn.setRequestProperty("X-CH-TS", timestamp);
            conn.setDoOutput(true);

            // Send request body
            try (OutputStream os = conn.getOutputStream()) {
                byte[] input = bodyJson.getBytes(StandardCharsets.UTF_8);
                os.write(input, 0, input.length);
            }

            // Read response
            int responseCode = conn.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            Scanner scanner = new Scanner(conn.getInputStream(), StandardCharsets.UTF_8.name());
            while (scanner.hasNextLine()) {
                System.out.println(scanner.nextLine());
            }
            scanner.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package main

import (
    "bytes"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io/ioutil"
    "net/http"
    "strconv"
    "time"
)

func main() {
    // API Relevant information
    url := "https://openapi.fameex.com"
    requestPath := "/sapi/v1/order/test"
    apiURL := url + requestPath
    apiKey := "your API-KEY"
    apiSecret := "your API-SECRET"

    // Generate the current millisecond-level timestamp
    timestamp := strconv.FormatInt(time.Now().UnixNano()/int64(time.Millisecond), 10)

    // Request method
    method := "POST"

    // Define the request body (JSON format)
    bodyJSON := `{"symbol":"BTCUSDT","price":"9300","volume":"1","side":"BUY","type":"LIMIT"}`

    // Generate Signature (X-CH-SIGN)
    signPayload := timestamp + method + requestPath + bodyJSON
    signature := hmacSHA256(signPayload, apiSecret)

    // **Print debug information**
    fmt.Println("==== Request information ====")
    fmt.Println("Timestamp (X-CH-TS):", timestamp)
    fmt.Println("Sign Payload (String to be signed):", signPayload)
    fmt.Println("Signature (X-CH-SIGN):", signature)
    fmt.Println("Request Body:", bodyJSON)
    fmt.Println("==================")

    // Send request
    sendPostRequest(apiURL, apiKey, timestamp, signature, bodyJSON)
}

// HMAC-SHA256 Signature calculation
func hmacSHA256(data, secret string) string {
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(data))
    return hex.EncodeToString(h.Sum(nil))
}

// Send HTTP POST request
func sendPostRequest(apiURL, apiKey, timestamp, signature, bodyJSON string) {
    client := &http.Client{}

    // Create request
    req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer([]byte(bodyJSON)))
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    // Set Headers
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-CH-SIGN", signature)
    req.Header.Set("X-CH-APIKEY", apiKey)
    req.Header.Set("X-CH-TS", timestamp)

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

    // Read response
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println("Response:", string(body))
}

import time
import hmac
import hashlib
import requests
import json

# API-related information
URL = "https://openapi.fameex.com"
REQUEST_PATH = "/sapi/v1/order/test"
API_URL = URL + REQUEST_PATH
API_KEY = "your API-KEY"
API_SECRET = "your API-SECRET"

# Generate the current millisecond-level timestamp
timestamp = str(int(time.time() * 1000))

# Request method
METHOD = "POST"

# Define the request body (JSON format)
body_json = {
    "symbol": "BTCUSDT",
    "price": "9300",
    "volume": "1",
    "side": "BUY",
    "type": "LIMIT"
}
body_str = json.dumps(body_json, separators=(',', ':'))  # Ensure the JSON string format is correct

# Generate signature (X-CH-SIGN)
sign_payload = timestamp + METHOD + REQUEST_PATH + body_str
signature = hmac.new(API_SECRET.encode(), sign_payload.encode(), hashlib.sha256).hexdigest()

# **Print debug information**
print("==== Request information ====")
print("Timestamp (X-CH-TS):", timestamp)
print("Sign Payload (String to be signed):", sign_payload)
print("Signature (X-CH-SIGN):", signature)
print("Request Body:", body_str)
print("==================")

# Send request
headers = {
    "X-CH-SIGN": signature,
    "X-CH-APIKEY": API_KEY,
    "X-CH-TS": timestamp,
    "Content-Type": "application/json"
}

response = requests.post(API_URL, headers=headers, data=body_str)

# Print response
print("Response Code:", response.status_code)
print("Response Body:", response.text)

<?

// API Relevant information
$url = "https://openapi.fameex.com";
$request_path = "/sapi/v1/order/test";
$api_url = $url . $request_path;
$api_key = "your API-KEY";
$api_secret = "your API-SECRET";

// Generate the current millisecond-level timestamp
$timestamp = round(microtime(true) * 1000);

// Request method
$method = "POST";

// Define the request body (JSON format)
$body_json = json_encode([
    "symbol" => "BTCUSDT",
    "price" => "9300",
    "volume" => "1",
    "side" => "BUY",
    "type" => "LIMIT"
], JSON_UNESCAPED_SLASHES); // Ensure the JSON format is correct

// Generate signature (X-CH-SIGN)
$sign_payload = $timestamp . $method . $request_path . $body_json;
$signature = hash_hmac('sha256', $sign_payload, $api_secret);

// **Print debug information**
echo "==== Request information ====\n";
echo "Timestamp (X-CH-TS): " . $timestamp . "\n";
echo "Sign Payload (String to be signed): " . $sign_payload . "\n";
echo "Signature (X-CH-SIGN): " . $signature . "\n";
echo "Request Body: " . $body_json . "\n";
echo "==================\n";

// Send request
$headers = [
    "Content-Type: application/json",
    "X-CH-SIGN: $signature",
    "X-CH-APIKEY: $api_key",
    "X-CH-TS: $timestamp"
];

// Use cURL to send a POST request
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $api_url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $body_json);

// Execute the request and retrieve the response
$response = curl_exec($ch);
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

// Print the response
echo "Response Code: $http_code\n";
echo "Response Body: $response\n";

const axios = require("axios");
const crypto = require("crypto");

// API-related information
const URL = "https://openapi.fameex.com";
const REQUEST_PATH = "/sapi/v1/order/test";
const API_URL = URL + REQUEST_PATH;
const API_KEY = "your API-KEY";
const API_SECRET = "your API-SECRET";

// Generate the current millisecond-level timestamp
const timestamp = Date.now().toString();

// Request method
const METHOD = "POST";

// Define the request body (in JSON format)
const bodyJson = JSON.stringify({
  symbol: "BTCUSDT",
  price: "9300",
  volume: "1",
  side: "BUY",
  type: "LIMIT",
});

// Generate signature (X-CH-SIGN)
const signPayload = timestamp + METHOD + REQUEST_PATH + bodyJson;
const signature = crypto
  .createHmac("sha256", API_SECRET)
  .update(signPayload)
  .digest("hex");

// **Print debug information**
console.log("==== Request information ====");
console.log("Timestamp (X-CH-TS):", timestamp);
console.log("Sign Payload (String to be signed):", signPayload);
console.log("Signature (X-CH-SIGN):", signature);
console.log("Request Body:", bodyJson);
console.log("==================");

// Send request
const headers = {
  "Content-Type": "application/json",
  "X-CH-SIGN": signature,
  "X-CH-APIKEY": API_KEY,
  "X-CH-TS": timestamp,
};

axios
  .post(API_URL, bodyJson, { headers })
  .then((response) => {
    console.log("Response Code:", response.status);
    console.log("Response Body:", response.data);
  })
  .catch((error) => {
    console.error("Error:", error.response ? error.response.data : error.message);
  });

{"symbol":"BTCUSDT","price":"9300","volume":"1","side":"BUY","type":"LIMIT"}

// Switch to Node.js to view 『JavaScript code (categorized under HTTP)』

# Generate X-CH-SIGN signature command
echo -n "1739520816000POST/sapi/v1/order/test{\"symbol\":\"BTCUSDT\",\"price\":\"9300\",\"volume\":\"1\",\"side\":\"BUY\",\"type\":\"LIMIT\"}" | openssl dgst -sha256 -hmac "709f1e13068f5e51123252d1e6851117"

# Generate X-CH-SIGN signature data
(stdin)= e496db94ec168f23d836d7c7be7223135e6fe6d9593e9c985a9e4017ed78a3f3

// HMAC-SHA256 Signature calculation
public static String hmacSha256(String data, String secret) throws Exception {
    Mac mac = Mac.getInstance("HmacSHA256");
    SecretKeySpec secretKeySpec = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
    mac.init(secretKeySpec);
    byte[] hash = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
    StringBuilder hexString = new StringBuilder();
    for (byte b : hash) {
        String hex = Integer.toHexString(0xff & b);
        if (hex.length() == 1) {
            hexString.append('0');
        }
        hexString.append(hex);
    }
    return hexString.toString();
}

// HMAC-SHA256 Signature calculation
func hmacSHA256(data, secret string) string {
    h := hmac.New(sha256.New, []byte(secret))
    h.Write([]byte(data))
    return hex.EncodeToString(h.Sum(nil))
}

# Generate signature (X-CH-SIGN)
sign_payload = timestamp + METHOD + REQUEST_PATH + body_str
signature = hmac.new(API_SECRET.encode(), sign_payload.encode(), hashlib.sha256).hexdigest()

// Generate signature (X-CH-SIGN)
$sign_payload = $timestamp . $method . $request_path . $body_json;
$signature = hash_hmac('sha256', $sign_payload, $api_secret);

// Generate signature (X-CH-SIGN)
const signPayload = timestamp + METHOD + REQUEST_PATH + bodyJson;
const signature = crypto
  .createHmac("sha256", API_SECRET)
  .update(signPayload)
  .digest("hex");

// JavaScript Code (categorized under HTTP)

let secretKey = pm.environment.get("SecretKey");  // Get API key from environment variables
let timestampString = String(Date.now()); // Generate a timestamp (precise to milliseconds)
let method = pm.request.method; // Get the request method (GET, POST, etc.)

let fullUrl = pm.request.url.toString();
let requestPath = "/"+fullUrl.split("/").slice(3).join("/"); // Get the part after `example.com`

// The `X-CH-SIGN` header is formed by concatenating the string `timestamp + method + requestPath + body` (where `+` indicates string concatenation)
// The `body` is the request body string (for POST requests only). If it's a GET request, the body can be omitted.
let signPayload = timestampString + method.toUpperCase() + requestPath;
if (method.toUpperCase() === "POST") {
    let body = pm.request.body ? pm.request.body.raw : null; // Get the request body (if available)
    if (body) {
        try {
            const parsedBody = JSON.parse(body); // Try to parse JSON
            let bodyString = JSON.stringify(parsedBody);
            signPayload += bodyString
        } catch (e) {
            signPayload += body; // If it's not JSON, directly append the raw body
        }
    } else {
        console.log("Failed to process body data for POST method");
    }
}

// The signature uses the HMAC SHA256 algorithm, with the API-Secret corresponding to the API-KEY as the key for HMAC SHA256.
const crypto = require('crypto-js'); // Load the CryptoJS library
// Calculate the signature
let signature = crypto.HmacSHA256(signPayload, secretKey).toString(crypto.enc.Hex);

// Set up Headers
pm.variables.set('xChTs', timestampString);
pm.variables.set('xChSign', signature);

{}

{
    "code": -1121,
    "msg": "Invalid symbol."
}

if (timestamp < (serverTime + 1000) && (serverTime - timestamp) <= recvWindow) {
  // process request
} else {
  // reject request
}

GET https://openapi.fameex.com/sapi/v1/ping

// Headers Setting 
Content-Type:application/json

curl -X GET "https://openapi.fameex.com/sapi/v1/ping"

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;

public class Main {
  public static void main(String[] args) {
    try {
      // Create a URL using URI
      URI uri = new URI("https://openapi.fameex.com/sapi/v1/ping");
      HttpURLConnection conn = (HttpURLConnection) uri.toURL().openConnection();
      conn.setRequestMethod("GET");
      conn.setRequestProperty("User-Agent", "Java-Client");

      // Read the response
      BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
      StringBuilder response = new StringBuilder();
      String line;
      while ((line = reader.readLine()) != null) {
        response.append(line);
      }
      reader.close();

      // Output result
      System.out.println("Response: " + response.toString());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://openapi.fameex.com/sapi/v1/ping"

    // Send a GET request
    resp, err := http.Get(url)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    // Read the response body
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Failed to read the response:", err)
        return
    }

    // Print the response
    fmt.Println("Server response:", string(body))
}

import requests

url = "https://openapi.fameex.com/sapi/v1/ping"

try:
    response = requests.get(url)
    response.raise_for_status()  # Check if the request was successful
    print("Response:", response.text)
except requests.exceptions.RequestException as e:
    print("Request error:", e)

<?
$url = "https://openapi.fameex.com/sapi/v1/ping";

// Initialization cURL
$ch = curl_init();

// Settings cURL Option
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); // Skip SSL certificate verification (if required by the API)

// Execute the request
$response = curl_exec($ch);

// Check for errors
if (curl_errno($ch)) {
    echo "cURL Error：" . curl_error($ch);
} else {
    echo "Response: " . $response;
}

// Close cURL
curl_close($ch);

const https = require('https');

const url = 'https://openapi.fameex.com/sapi/v1/ping';

https.get(url, (res) => {
  let data = '';

  // A chunk of data has been received.
  res.on('data', (chunk) => {
    data += chunk;
  });

  // The whole response has been received.
  res.on('end', () => {
    console.log("Response:", data);
  });

}).on('error', (err) => {
  console.log('Request error:', err.message);
});

{}

GET https://openapi.fameex.com/sapi/v1/time

// Headers Setting
Content-Type:application/json

curl -X GET "https://openapi.fameex.com/sapi/v1/time"

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;

public class Main {
  public static void main(String[] args) {
    try {
      // Create a URL using URI
      URI uri = new URI("https://openapi.fameex.com/sapi/v1/time");
      HttpURLConnection conn = (HttpURLConnection) uri.toURL().openConnection();
      conn.setRequestMethod("GET");
      conn.setRequestProperty("User-Agent", "Java-Client");

      // Create a URL using URI.
      BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
      StringBuilder response = new StringBuilder();
      String line;
      while ((line = reader.readLine()) != null) {
        response.append(line);
      }
      reader.close();

      // Output result
      System.out.println("Response: " + response.toString());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://openapi.fameex.com/sapi/v1/time"

    // Send a GET request
    resp, err := http.Get(url)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    // Read the response body
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Failed to read the response:", err)
        return
    }

    // Print the response
    fmt.Println("Server response:", string(body))
}

import requests

url = "https://openapi.fameex.com/sapi/v1/time"

try:
    response = requests.get(url)
    response.raise_for_status()  # Check if the request was successful
    print("Response:", response.text)
except requests.exceptions.RequestException as e:
    print("Request error:", e)

<?
$url = "https://openapi.fameex.com/sapi/v1/time";

// Initialization cURL
$ch = curl_init();

// Set cURL options
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); // Skip SSL certificate verification (if required by the API)

// Execute the request
$response = curl_exec($ch);

// Check for errors
if (curl_errno($ch)) {
    echo "cURL Error：" . curl_error($ch);
} else {
    echo "Response: " . $response;
}

// Close cURL
curl_close($ch);

const https = require('https');

const url = 'https://openapi.fameex.com/sapi/v1/time';

https.get(url, (res) => {
  let data = '';

  // A chunk of data has been received.
  res.on('data', (chunk) => {
    data += chunk;
  });

  // The whole response has been received.
  res.on('end', () => {
    console.log("Response:", data);
  });

}).on('error', (err) => {
  console.log('Request error:', err.message);
});

{
    "timezone": "China Standard Time",
    "serverTime": 1705039779880
}

GET https://openapi.fameex.com/sapi/v1/symbols

// Headers  setting
Content-Type:application/json

curl -X GET "https://openapi.fameex.com/sapi/v1/symbols"

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;

public class Main {
  public static void main(String[] args) {
    try {
      // Use URI to create URL
      URI uri = new URI("https://openapi.fameex.com/sapi/v1/symbols");
      HttpURLConnection conn = (HttpURLConnection) uri.toURL().openConnection();
      conn.setRequestMethod("GET");
      conn.setRequestProperty("User-Agent", "Java-Client");

      // Read response
      BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
      StringBuilder response = new StringBuilder();
      String line;
      while ((line = reader.readLine()) != null) {
        response.append(line);
      }
      reader.close();

      // Output result
      System.out.println("Response: " + response.toString());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://openapi.fameex.com/sapi/v1/symbols"

    // Send GET request
    resp, err := http.Get(url)
    if err != nil {
        fmt.Println("Request failed:", err)
        return
    }
    defer resp.Body.Close()

    // Read response body
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Failed to read response:", err)
        return
    }

    // Print response
    fmt.Println("Server response:", string(body))
}

import requests

url = "https://openapi.fameex.com/sapi/v1/symbols"

try:
    response = requests.get(url)
    response.raise_for_status()  # Check if the request is successful
    print("Response:", response.text)
except requests.exceptions.RequestException as e:
    print("Request error:", e)

<?
$url = "https://openapi.fameex.com/sapi/v1/symbols";

// Initialize cURL
$ch = curl_init();

// Set cURL options
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); // Skip SSL certificate verification (if required by the API)

// Execute request
$response = curl_exec($ch);

// Check for errors
if (curl_errno($ch)) {
    echo "cURL Error：" . curl_error($ch);
} else {
    echo "Response: " . $response;
}

// Close cURL
curl_close($ch);

const https = require('https');

const url = 'https://openapi.fameex.com/sapi/v1/symbols';

https.get(url, (res) => {
  let data = '';

  // A chunk of data has been received.
  res.on('data', (chunk) => {
    data += chunk;
  });

  // The whole response has been received.
  res.on('end', () => {
    console.log("Response:", data);
  });

}).on('error', (err) => {
  console.log('Request error:', err.message);
});

{
    "symbols": [
        {
            "quantityPrecision": 3,
            "limitVolumeMin": 0.0001,
            "symbol": "sccadai",
            "pricePrecision": 6,
            "marketBuyMin": 0.0001,
            "marketSellMin": 0.0001,
            "baseAsset": "SCCA",
            "limitPriceMin": 0.001,
            "quoteAsset": "DAI"
        },
        {
            "quantityPrecision": 8,
            "limitVolumeMin": 0.0001,
            "symbol": "btcusdt",
            "pricePrecision": 2,
            "marketBuyMin": 0.0001,
            "marketSellMin": 0.0001,
            "baseAsset": "BTC",
            "limitPriceMin": 0.001,
            "quoteAsset": "USDT"
        },
        {
            "quantityPrecision": 3,
            "limitVolumeMin": 0.0001,
            "symbol": "bchusdt",
            "pricePrecision": 2,
            "marketBuyMin": 0.0001,
            "marketSellMin": 0.0001,
            "baseAsset": "BCH",
            "limitPriceMin": 0.001,
            "quoteAsset": "USDT"
        },
        {
            "quantityPrecision": 2,
            "limitVolumeMin": 0.0001,
            "symbol": "etcusdt",
            "pricePrecision": 2,
            "marketBuyMin": 0.0001,
            "marketSellMin": 0.0001,
            "baseAsset": "ETC",
            "limitPriceMin": 0.001,
            "quoteAsset": "USDT"
        },
        {
            "quantityPrecision": 2,
            "limitVolumeMin": 0.0001,
            "symbol": "ltcbtc",
            "pricePrecision": 6,
            "marketBuyMin": 0.0001,
            "marketSellMin": 0.0001,
            "baseAsset": "LTC",
            "limitPriceMin": 0.001,
            "quoteAsset": "BTC"
        }
    ]
}